美文网首页互联网科技程序猿阵线联盟-汇总各类技术干货Java基础
java基础thread——多线程的纷争（循序渐进）

java基础thread——多线程的纷争（循序渐进）

作者: 徐同学呀 | 来源:发表于2018-05-30 21:48 被阅读95次

    一、多线程概述

    进程：

    正在运行的程序，是系统进行资源分配和调用的独立单位。
    每一个进程都有它自己的内存空间和系统资源。

    多进程有什么意义呢?

    单进程的计算机只能做一件事情，而我们现在的计算机都可以做多件事情。
    举例：一边玩游戏(游戏进程)，一边听音乐(音乐进程)。
    也就是说现在的计算机都是支持多进程的，可以在一个时间段内执行多个任务。
    并且呢，可以提高CPU的使用率。

    那问题来了，一边玩游戏，一边听音乐是同时进行的吗?

    不是。因为单CPU在某一个时间点上只能做一件事情。
    而我们在玩游戏，或者听音乐的时候，是CPU在做着程序间的高效切换让我们觉得是同时进行的。

    线程：

    在同一个进程内又可以执行多个任务，而这每一个任务就可以看作是一个线程。
    线程是程序的执行单元，执行路径。是程序使用CPU的最基本单位。

    单线程：
    如果程序只有一条执行路径。

    多线程：
    如果程序有多条执行路径。

    多线程有什么意义呢?

    多线程的存在，不是提高程序的执行速度。其实是为了提高应用程序的使用率。
    程序的执行其实都是在抢CPU的资源，CPU的执行权。
    多个进程是在抢这个资源，而其中的某一个进程如果执行路径比较多，就会有更高的几率抢到CPU的执行权。
    我们是不敢保证哪一个线程能够在哪个时刻抢到，所以线程的执行有随机性。

    Java程序运行原理

    java 命令会启动 java 虚拟机，启动 JVM，等于启动了一个应用程序，也就是启动了一个进程。该进程会自动启动一个 “主线程” ，然后主线程去调用某个类的 main 方法。所以 main方法运行在主线程中。在此之前的所有程序都是单线程的。

    思考一个问题，
    jvm虚拟机的启动是单线程的还是多线程的？

    JVM的启动是多线程的，因为它最低有两个线程启动了，主线程和垃圾回收线程。

    我们要如何实现多线程程序呢？

    由于线程是依赖进程而存在的，所以我们应该先创建一个进程出来。而进程是由系统创建的，所以我们应该去调用系统功能创建一个进程。Java是不能直接调用系统功能的，所以，我们没有办法直接实现多线程程序。但是呢?Java可以去调用C/C++写好的程序来实现多线程程序。
    由C / C ++去调用系统功能创建进程，然后由Java去调用这样的东西，然后提供一些类供我们使用。我们就可以实现多线程程序了。

    二、多线程的实现（继承与实现）

    继承Thread类（第一种方案）

    MyThread.java

    public class MyThread extends Thread {

    public MyThread() {
    }
    public MyThread(String name){
        super(name);
    }
    @Override
    public void run(){
        try {
            Thread.sleep(5000);
            for (int x = 0; x < 10; x++) {
                System.out.println(getName() + ":" + x);
                Thread.yield();
            }
        } catch (InterruptedException e) {
            System.out.println("线程中断");
            e.printStackTrace();
        }
        System.out.println("结束");

    }
}

    test1.java

    public class test1 {
    public static void main(String[] args) {
        System.out.println(Thread.currentThread().getName());//main
        MyThread my1 = new MyThread("线程一");
        MyThread my2 = new MyThread("线程二");
        my1.start();
        my2.start();
        //发现两个线程在抢着执行
    }
}
    步骤：
    1. 自定义类MyThread 继承Thread
    2. 在MyThread 中重写run()
    3. 创建MyThread的对象
    4. 启动线程对象(start())
    考虑几个小问题：
    • 为什么要重写run()方法？——因为run()里的代码才会被线程执行。
    • 启动线程使用的是那个方法？ —— start()
    • 线程能不能多次启动？——不能。一个线程多次启动会报错，IllegalThreadStateException:非法的线程状态异常
      为什么呢?因为这个相当于是my线程被调用了多次，而不是多个线程启动。
    • run()和start()方法的区别？——run() 仅仅是封装被线程执行的代码,就是普通的方法;start()首先启动了线程，然后再由jvm去调用该线程的run()方法。

    如何获取和设置线程的名称？

    Thread类的线程名获取和设置方法

    public final String getName()
public final void setName(String name)

    其实通过构造方法也可以给线程起名字

    public Thread(String name) {
        init(null, null, name, 0);
    }

    代码示意：

    MyThread my1 = new MyThread("线程一");
MyThread my2 = new MyThread("线程二");
my1.setName("线程1");
my1.getName();
my1.start();
my2.start();

    还有一种方式：
    获得和设置当前线程的名字。

    Thread.currentThread().getName()
Thread.currentThread().setName("主线程");

    线程调度

    线程有两种调度模型：
    • 分时调度模型：
      所有线程轮流使用 CPU 的使用权，平均分配每个线程占用 CPU 的时间片
    • 抢占式调度模型：
      优先让优先级高的线程使用 CPU，如果线程的优先级相同，那么会随机选择一个，优先级高的线程获取的 CPU 时间片相对多一些。

    Java使用的是抢占式调度模型。

    设置和获取优先级

    我们的线程没有设置优先级,肯定有默认优先级。
    那么，默认优先级是多少呢?

    获取线程对象的优先级：

    public final int getPriority():返回线程对象的优先级

    设置线程对象的优先级：

    public final void setPriority(int newPriority)：更改线程的优先级。

    线程默认优先级是5。

    线程优先级的范围是：1-10。

    线程优先级高仅仅表示线程获取的 CPU时间片的几率高，但是要在次数比较多，或者多次运行的时候才能看到比较好的效果。

    MyThread my1 = new MyThread("线程一");
MyThread my2 = new MyThread("线程二");
MyThread my3 = new MyThread("线程三");
System.out.println(my1.getPriority());//默认调度5
my2.setPriority(Thread.MIN_PRIORITY);//1 最小
my3.setPriority(Thread.MAX_PRIORITY);//10 最大
my1.setPriority(Thread.NORM_PRIORITY);//5  默认

    线程控制

    • 线程休眠
      public static void sleep(long millis)
    • 线程加入
      public final void join()
    • 线程礼让
      public static void yield()
    • 后台线程
      public final void setDaemon(boolean on)
    • 中断线程
      public final void stop()、
      public void interrupt()

    sleep()
    线程休眠就是模拟阻塞，把调用cpu的机会交给其他线程。

    public class ThreadSleep extends Thread {
    @Override
    public void run() {
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
    }
}

    join()
    当某个线程被join()后，其他线程必须等这个线程执行完毕，才能执行其他线程。

     MyThread my1 = new MyThread("线程一");
 MyThread my2 = new MyThread("线程二");
 my2.start();
 my2.join();
 my1.start();
 //线程二执行完了，线程一才执行

    yield()
    暂停当前正在执行的线程对象，并执行其他线程。让多个线程的执行更和谐，但是不能靠它保证一人一次。

    @Override
    public void run(){
        for (int x = 0; x < 10; x++) {
            System.out.println(getName() + ":" + x);
            Thread.yield();
            }
    }

    setDaemon(boolean on)
    将该线程标记为守护线程或用户线程。当正在运行的线程都是守护线程时，Java 虚拟机退出。 该方法必须在启动线程前调用。

    当主线程main结束后，守护线程也就停止了。

    public class ThreadDaemonDemo {
    public static void main(String[] args) {
        ThreadDaemon td1 = new ThreadDaemon();
        ThreadDaemon td2 = new ThreadDaemon();

        td1.setName("关羽");
        td2.setName("张飞");

        // 设置收获线程
        td1.setDaemon(true);
        td2.setDaemon(true);

        td1.start();
        td2.start();

        Thread.currentThread().setName("刘备");
        for (int x = 0; x < 5; x++) {
            System.out.println(Thread.currentThread().getName() + ":" + x);
        }
    }
}

    守护线程的栗子：坦克大战

    坦克大战图解.jpg

    stop()、interrupt()
    stop()官方已经弃用，终止线程推荐interrupt()

    public final void stop():让线程停止，过时了，但是还可以使用。

    public void interrupt():中断线程。 把线程的状态终止，并抛出一个InterruptedException。

    代码演示：

    public class MyThreadStop extends Thread {
    @Override
    public void run() {
        System.out.println("开始执行：" + new Date());

        // 我要休息10秒钟，亲，不要打扰我哦
        try {
            Thread.sleep(10000);
        } catch (InterruptedException e) {
            // e.printStackTrace();
            System.out.println("线程被终止了");
        }

        System.out.println("结束执行：" + new Date());
    }
}

public class test3 {
    public static void main(String[] args) {
        MyThreadStop mys = new MyThreadStop();
        mys.start();
        try {
            Thread.sleep(3000);
            mys.stop();
            //mys.interrupt();
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        //发现两个线程在抢着执行
    }
}

//stop() 运行打印：
开始执行：Wed May 30 20:29:34 CST 2018

//run里没执行就暴力的终止了

//interrupt() 运行打印

开始执行：Wed May 30 20:31:49 CST 2018
线程被终止了
结束执行：Wed May 30 20:31:52 CST 2018

    注：终止线程推荐interrupt()

    线程的生命周期：
    线程.png

    实现Runnable接口（第二种方案）

    public class MyRunnable implements Runnable {
    @Override
    public void run() {
        for (int i = 0; i <10 ; i++) {
            System.out.println(Thread.currentThread().getName()+"-"+i);
        }
    }
}


public class test1 {
    public static void main(String[] args) {
        MyRunnable mr = new MyRunnable();
        Thread t1 = new Thread(mr,"线程一");
        Thread t2 = new Thread(mr,"线程二");
        t1.start();
        t2.start();
    }
}
    步骤：
    1. 自定义类MyRunnable实现Runnable接口
    2. 重写run()方法
    3. 创建MyRunnable类的对象
    4. 创建Thread类的对象，并把C步骤的对象作为构造参数传递
    @FunctionalInterface
public interface Runnable {
    public abstract void run();
}

    从源码看出，Runnable是一个接口，只有一个run(),并没有name参数，所以我们该怎么获得和设置线程的名字呢。

    Thread.currentThread().getName()
Thread.currentThread().setName("线程名")

    再看看源码,发现Thread也实现了Runnable这个接口。

    问题来了，为什么有了继承Thread实现线程的方式，还要有实现Runnable接口的方式。

    原因如下：

    • 避免由于java单继承带来的局限性
    • 适合多个相同程序的代码去处理同一个资源的情况，把线程同程序的代码，数据有效分离，较好的体现了面向对象的设计思想。

    举个栗子：

    某电影院目前正在上映贺岁大片，共有100张票，而它有3个售票窗口售票，请设计一个程序模拟该电影院售票。

    方式一：用继承Thread来模拟

    public class SellTickets extends Thread {
    public SellTickets(){

    }
    public SellTickets(String name){
        super(name);
    }
    private static int ticket = 20;//为了让三个窗口共享，设置为static的
    @Override
    public void run(){
            try {
                while (true) {
                    if (ticket<=0){
                        break;
                    }
                    System.out.println(getName()+"正在售卖第" + (ticket--) + "票");
                    Thread.sleep(3000);//模拟网络延时
                }
            } catch (InterruptedException e) {
                e.printStackTrace();
            }

    }
}

public class test1 {
    public static void main(String[] args) throws InterruptedException {
        SellTickets st1 = new SellTickets("窗口一");
        SellTickets st2 = new SellTickets("窗口二");
        SellTickets st3 = new SellTickets("窗口三");
        st1.start();
        st2.start();
        st3.start();
    }
}

//运行结果你会发现，三个窗口可以卖同一张票。并且会出现负票

    另一种方式模拟：

    public class SellTicket2 implements Runnable {
    private int ticket = 20;
    @Override
    public void run() {
        while (true){
            if (ticket<=0){
                break;
            }
            //卖票这个动作不安全。
            System.out.println(Thread.currentThread().getName()+"正在售卖第" + (ticket--) + "票");
        }
    }
}


public class test2 {
    public static void main(String[] args) throws InterruptedException {
       SellTicket2 st = new SellTicket2();
       Thread t1 = new Thread(st,"一");
       Thread t2 = new Thread(st,"二");
       Thread t3 = new Thread(st,"三");
       t1.start();
       t2.start();
       t3.start();
    }
}

同样的问题出现了，出现多个窗口买同一张票，出现负票。

    这足以说明，以上两种方式是线程不安全的。（推荐实现接口Runnable 的模拟）

    三、解决线程安全问题的基本思想

    出现线程安全问题的情况
    • 多线程环境
    • 有共享数据
    • 有多条语句操作共享数据

    解决方案：

    同步代码块
    synchronized(对象){

需要同步的代码;
    
}

    两个问题：

    • 对象是什么呢? ——测试所得 任意对象做锁
    • 需要同步的代码是哪些呢?——把多条语句操作共享数据的代码的部分给包起来

    注意：同步可以解决安全问题的根本原因就在那个对象上。该对象如同锁的功能。

    多个线程必须是同一把锁。同一把锁，对象必须只有一个。

    卖票升级：

    public class SellTicket3 implements Runnable {
    private int ticket = 100;
    //定义同一把锁对象
    private Object obj = new Object();
    @Override
    public void run() {
            while (true) {
                synchronized (obj) {
                if (ticket <= 0) {
                    break;
                }
                System.out.println(Thread.currentThread().getName() + "正在售卖第" + (ticket--) + "票");
            }
        }
    }
}

    解释：当窗口一进入同步代码块，就相当于上锁，在这期间别的窗口只能在外面等待，等窗口一把自己的事做完了，离开了代码块，这时三个窗口又重新竞争进入同步代码块的机会。

    同步方法：

    就是把同步关键字加到方法上。

    //如果一个方法一进去就看到了代码被同步了，那么我就再想能不能把这个同步加在方法上呢?,
    public synchronized void pay(){
        if (ticket > 0) {
            System.out.println(Thread.currentThread().getName() + "正在售卖第" + (ticket--) + "票");    }
    }

    而我们想同步方法的锁对象是谁？经测试是this，所以我们一般也把同步代码块的对象也设置为this。

    方法有静态方法，那么同步静态方法的锁对象又是谁？

    经测试是类的字节码文件对象，就是.class。

    总结：
    同步的前提
    • 多个线程
    • 多个线程使用的是同一个锁对象
    同步的好处

    同步的出现解决了多线程的安全问题。

    同步的弊端

    当线程相当多时，因为每个线程都会去判断同步上的锁，这是很耗费资源的，无形中会降低程序的运行效率。

    同步的锁对象
    • 同步代码块——任意对象可以做锁对象（推荐this）
    • 同步方法——this
    • 同步静态方法——类.class

    回顾java源码里线程安全的类

    // 线程安全的类
StringBuffer sb = new StringBuffer();
Vector<String> v = new Vector<String>();
Hashtable<String, String> h = new Hashtable<String, String>();

    我们之前经常用到的集合都是不安全的。java给我们提供了线程安全的集合

    List<String> list1 = new ArrayList<String>();// 线程不安全
        List<String> list2 = Collections
                .synchronizedList(new ArrayList<String>()); // 线程安全
    image

    源码码云地址：
    https://gitee.com/stefanpy/java

    相关文章

      网友评论

        本文标题：java基础thread——多线程的纷争（循序渐进）

        本文链接：https://www.haomeiwen.com/subject/hbaxsftx.html

        延伸阅读

        深度阅读

        • 您也可以注册成为美文阅读网的作者，发表您的原创作品、分享您的心情！

        栏目导航

        热点阅读

        互联网科技

        程序猿阵线联盟-汇总各类技术干货

        Java基础

        编程语言爱好者

        我爱编程

        程序员

        关于我们|服务条款|联系我们|java基础thread——多线程的纷争（循序渐进）|投稿指南|网站地图|RSS订阅|排版工具|手机版

        提供经典美文摘抄,优美散文欣赏,现代诗歌精选,短篇小说,心情随笔,表白情书范文,故事会在线阅读欣赏

        Copyright © 2014-2023 Haomeiwen.com All Rights Reserved. 好美文阅读网 版权所有

        备案信息：桂公网安备 45052102000051号 · 桂ICP备13007215号-3

        本站所收录作品、热点评论等信息部分来源互联网，目的只是为了系统归纳学习和传递资讯

        所有作品版权归原创作者所有，与本站立场无关，如不慎侵犯了你的权益，请联系我们告知，我们将做删除处理！