java之多线程总结

最新推荐文章于 2021-04-23 14:02:40 发布

谢晓永

最新推荐文章于 2021-04-23 14:02:40 发布

阅读量300

点赞数

分类专栏： java基础

本文链接：https://blog.csdn.net/xiaoyong5854/article/details/106985060

版权

java基础专栏收录该内容

15 篇文章 1 订阅

订阅专栏

1 概念

操作系统的基本特征包括并发、共享、虚拟和异步。

1.并发
操作系统的并发性是指计算机系统中同时存在多个运行着的程序，因此它具有处理和调度多个程序同时执行的能力，引入进程的目的是使程序能并发执行。

并发：指两个事件或多个事件在同一个时间段内发生。
并行：指两个或多个事件在同一时刻发生（同时发生）。

2.共享
资源共享即共享，是指系统中的资源可供内存中多个并发执行的进程共同使用，共享可分为以下两种资源共享方式。

（1）互斥共享方式
当进程A访问某资源时，必须先提出请求，如果此时资源空闲，系统便可以将之分配给进程A使用，此后若有其他进程也要访问该资源时（A未使用完），则必须等待。仅当A资源访问完并释放资源后，才允许另一进程对该资源进行访问。在一段时间内只允许一个进程访问的资源成为临界资源或独占资源。
例如打印机、磁带机等。

（2）同时访问方式
系统中还有另一类资源，允许在一段时间内由多个进程“同时”（宏观的同时，微观上交替访问）对它们进行访问，例如磁盘设备。

3.虚拟
虚拟是指把一个物理上的实体变为若干个逻辑上的对应物。

4.异步
在多道程序环境下，允许多个程序并发执行，但由于资源有限，进程的执行不是一贯到底，而是走走停停，以不可预知的速度向前推进，这就是进程的异步性。

5.进程
是指一个内存中运行的应用程序，每个进程都有一个独立的内存空间，一个应用程序可以同时运行多个进程；进程也是程序的一次执行过程，是系统运行程序的基本单位；系统运行一个程序从创建、运行到消亡的过程。

6.线程
线程是进程中的一个执行单元，负责当前进程中程序的执行，一个进程中至少有一个线程。一个进程中是可以有多个线程的，这个应用程序也可以称之为多线程程序。
简而言之：一个程序运行至少有一个进程，一个进程中包含有多个线程。

7.线程调度
（1）分时调度
所有线程轮流使用CPU的使用权，平均分配每个线程占用CPU的时间。

（2）抢占式调度
优先让优先级高的线程使用CPU，如果线程的优先级相同，那么会随机选择一个，Java使用的为抢占式调度。

8.多线程
　多进程是指操作系统能同时运行多个任务（程序），多线程是指在同一程序中有多个顺序流在执行。
　多线程内存图如下:
　在这里插入图片描述

Java使用java.lang.Thread类代表线程，所有的线程对象都必须是Thread类或其子类的实例。每个线程的作用是完成一定的任务，实际上就是执行一段程序流即一段顺序执行的代码。Java使用线程执行体来代表这段程序流。Java中通过继承Thread类来创建并启动多线程的步骤如下：

定义Thread类的子类，并重写该类的run()方法，该run()方法的方法体就代表了线程需要完成的任务,因此把run()方法称为线程执行体。
创建Thread子类的实例，即创建了线程对象
调用线程对象的start()方法来启动该线程

代码运行如下：

package Demo11;

public class Demo {
    public static void main(String[] args) {
        System.out.println("这里是main线程");
        MyThread mt = new MyThread("小强");
        mt.start();//开启了一个新的线程
        for (int i = 0; i < 20; i++) {
            System.out.println("旺财"+i);
        }
    }
}

public class MyThread extends Thread {
    public MyThread(String name) {
        super(name);
    }

    @Override
    public void run() {
        for (int i = 0; i < 20; i++) {
            System.out.println(getName()+i);
            //getName()方法，来自父亲
        }
    }
}

运行结果如图：
在这里插入图片描述

流程图如下：
在这里插入图片描述程序启动运行main时候，java虚拟机启动一个进程，主线程main在main()调用时候被创建。随着调用mt的对象的 start方法，另外一个新的线程也启动了，这样，整个应用就在多线程下运行。
通过这张图我们可以很清晰的看到多线程的执行流程，那么为什么可以完成并发执行呢？我们再来讲一讲原理。
多线程执行时，到底在内存中是如何运行的呢？以上个程序为例，进行图解说明：
多线程执行时，在栈内存中，其实每一个执行线程都有一片自己所属的栈内存空间。进行方法的压栈和弹栈。

2 Thread类

构造方法：

public Thread()：分配一个新的线程对象。
public Thread(String name)：分配一个指定名字的新的线程对象。
public Thread(Runnable target)：分配一个带有指定目标新的线程对象。
public Thread(Runnable target, String name)：分配一个带有指定目标新的线程对象并指定名字。

常用方法：

public String getName( )：获取当前线程名称。
public void start( )：导致此线程开始执行；java虚拟机调用此线程的run方法。
public void run( )：此线程要执行的任务在此处定义代码。
public static void sleep(long millis)：使当前正在执行的线程以指定的毫秒数暂停（暂时停止执行）。
public static Thread currentThread( )：返回当前正在执行的线程对象的引用。

代码运行如下:

public class Demo01Thread {
    public static void main(String[] args) throws InterruptedException {
        //创建Thread类的子类对象
        MyThread mt1 = new MyThread();
        //调用start方法，开启新线程，执行run方法
        mt1.start();

        new MyThread().start();
        new MyThread().start();

        //链式编程
        System.out.println(Thread.currentThread().getName());
        System.out.println("=================================");
        MyThread.sleep(1000);

        new MyThread("小强").start();
        MyThread mt2 = new MyThread();
        mt2.setName("旺财");
        mt2.start();
    }
}

运行结果如图：

在这里插入图片描述

3 Runnable接口

采用java.lang.Runnable是一种常见的创建线程的方式，只需要重写run方法即可。

步骤如下：

定义Runnable接口的实现类，并重写该接口的run()方法，该run()方法的方法体同样是该线程的线程执行体。
创建Runnable实现类的实例，并以此实例作为Thread的target来吃创建Thread对象，该Thread对象才是真正的线程对象。
调用线程对象的start()方法来启动线程。

代码如下：

package Demo04;
/*
    创建多线程程序的第二种方式:实现Runnable接口
    java.lang.Runnable
        Runnable 接口应该由那些打算通过某一线程执行其实例的类来实现。类必须定义一个称为 run 的无参数方法。
    java.lang.Thread类的构造方法
        Thread(Runnable target) 分配新的 Thread 对象。
        Thread(Runnable target, String name) 分配新的 Thread 对象。

    实现步骤:
        1.创建一个Runnable接口的实现类
        2.在实现类中重写Runnable接口的run方法,设置线程任务
        3.创建一个Runnable接口的实现类对象
        4.创建Thread类对象,构造方法中传递Runnable接口的实现类对象
        5.调用Thread类中的start方法,开启新的线程执行run方法

    实现Runnable接口创建多线程程序的好处:
        1.避免了单继承的局限性
            一个类只能继承一个类(一个人只能有一个亲爹),类继承了Thread类就不能继承其他的类
            实现了Runnable接口,还可以继承其他的类,实现其他的接口
        2.增强了程序的扩展性,降低了程序的耦合性(解耦)
            实现Runnable接口的方式,把设置线程任务和开启新线程进行了分离(解耦)
            实现类中,重写了run方法:用来设置线程任务
            创建Thread类对象,调用start方法:用来开启新线程
 */
public class Demo01Runnable {
    public static void main(String[] args) {
        //3.创建一个Runnable接口的实现类对象
        Runnable run = new RunnableImpl();
        //4.创建Thread类对象，构造方法中传递Runnable接口的实现类对象
        Thread t = new Thread(run);
        //Thread t = new Thread(new RunnableImpl2());
        //5.调用Thread类中的start方法,开启新的线程执行run方法
        t.start();
        System.out.println("====================");
        for (int i = 0; i < 20; i++) {
            System.out.println(Thread.currentThread().getName()+"-->"+i);
        }
       // System.out.println("====================");
        Runnable run2 = new RunnableImpl2();
        Thread t2 = new Thread(run2);
        t2.start();
    }
}

//1.创建一个Runnable接口的实现类
public class RunnableImpl implements Runnable{

    //2.在实现类中重写Runnable接口的run方法,设置线程任务
    @Override
    public void run() {
        for (int i = 0; i < 20; i++) {
            System.out.println(Thread.currentThread().getName()+"-->"+i);
        }
    }
}

//1.创建一个Runnable接口的实现类
public class RunnableImpl2 implements Runnable {
    //2.在实现类中重写Runnable接口的run方法,设置线程任务
    @Override
    public void run() {
        for (int i = 0; i < 20; i++) {
            System.out.println("HelloWorld"+i);
        }
    }
}

运行结果如图：
在这里插入图片描述

通过实现Runnable接口，使得该类有了多线程的特征。run()方法是多线程程序的一个执行目标。所有的多线程代码都在run方法里面。Thread类实际上也是实现了Runnable接口的类。

在启动的多线程的时候，需要先通过Thread类的构造方法Thread(Runnable target)构造对象，然后调用Thread对象的start()方法来运行多线程代码。

实际上所有的多线程代码都是通过运行Thread的start()方法来运行的，因此，不管是继承Thread类还是实现Runnable接口来实现多线程，最终还是通过Thread的对象的API来控制线程的，熟悉Thread类的API是进行多线程编程的基础。

注意：Runnable对象仅仅作为Thread对象的target，Runnable实现类里的包含的run()方法仅作为线程执行体。而实际的线程对象依然是Thread实例，只是该Thread线程负责其target的run()方法。

3.1 Thread和Runnable的区别

如果一个类继承Thread，则不适合资源共享。但是如果实现了Runnable接口的话，则很容易实现资源共享。

实现Runnable接口比继承Thread类所具有的优势：

适合多个相同的程序代码的线程去共享同一个资源。
可以避免java中的单继承的局限性。
增加程序的健壮性，实现解耦操作，代码可以被多个线程共享，代码和线程独立。
线程池只能放入实现Runnable或Callable类线程，不能直接放入继承Thread的类。

注意：在java中，每次程序运行至少启动2个线程，一个是main线程，一个是垃圾收集线程。因为每当使用java命令执行一个类的时候，实际上都会启动一个JVM，每个JVM其实就是在操作系统中启动了额一个进程。

3.2 匿名内部类方式实现线程的创建

使用线程的匿名内部类方式，可以方便的实现每个线程执行不同的线程任务操作。
使用匿名内部类的方式实现Runnable接口，重新Runnable接口中的run方法：

代码如下：

package Demo05;

import Demo04.RunnableImpl;

/*
    匿名内部类方式实现线程的创建

    匿名:没有名字
    内部类:写在其他类内部的类

    匿名内部类作用:简化代码
        把子类继承父类,重写父类的方法,创建子类对象合一步完成
        把实现类实现类接口,重写接口中的方法,创建实现类对象合成一步完成
    匿名内部类的最终产物:子类/实现类对象,而这个类没有名字

    格式:
        new 父类/接口(){
            重复父类/接口中的方法
        };
 */
public class Demo05InnerClassThread {
    public static void main(String[] args) {
    //线程的父类是Thread
    // new MyThread().start();
        new Thread(){
            @Override
            public void run(){
                for (int i = 0; i < 20; i++) {
                    System.out.println(Thread.currentThread().getName()+"-->java"+i);
                }
            }
        }.start();

        //线程的接口Runnable
        //Runnable r = new RunnableImpl();//多态
        Runnable r = new RunnableImpl() {//多态
            //重写run方法，设置线程方法
            @Override
            public void run() {
                for (int i = 0; i < 20; i++) {
                    System.out.println(Thread.currentThread().getName()+"-->javase"+i);
                }
            }
        };
        new Thread(r).start();

        //简化接口的方式
        new Thread(new Runnable() {
            @Override
            public void run() {
                for (int i = 0; i < 20; i++) {
                    System.out.println(Thread.currentThread().getName()+"-->R"+i);
                }
            }
        }).start();
    }
}

运行结果如图：
在这里插入图片描述

4 线程安全

如果有多个线程在同时运行，而这些线程可能会同时运行这段代码，程序每次运行结果和单线程运行的结果是一样的，而且其他的变量值也和预期的是一样的，就是说线程是安全的。

通过案例演示线程的安全问题如下：
模拟电影院的卖票过程，本次电影的座位共100个，实现多个窗口同时卖票，需要窗口，采用线程对象来模拟；需要票，Runnable接口子类来模拟。

代码运行如下：

/*
    模拟卖票案例
    创建3个线程,同时开启,对共享的票进行出售
 */
public class Demo01Ticket {
    public static void main(String[] args) {
        //创建Runnable接口的实现类对象
        RunnableImpl run = new RunnableImpl();
        //创建Thread类对象,构造方法中传递Runnable接口的实现类对象
        Thread t0 = new Thread(run);
        Thread t1 = new Thread(run);
        Thread t2 = new Thread(run);
        //调用start方法开启多线程
        t0.start();
        t1.start();
        t2.start();
    }
}

public class RunnableImpl implements Runnable{
    //定义一个多个线程共享的票源
    private  int ticket = 100;


    //设置线程任务:卖票
    @Override
    public void run() {
        //使用死循环,让卖票操作重复执行
        while(true){
            //先判断票是否存在
            if(ticket>0){
                //提高安全问题出现的概率,让程序睡眠
                try {
                    Thread.sleep(10);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }

                //票存在,卖票 ticket--
                System.out.println(Thread.currentThread().getName()+"-->正在卖第"+ticket+"张票");
                ticket--;
            }
        }
    }
}

部分结果如图：
在这里插入图片描述

发现程序出现了两个问题：

相同的票数被卖了多次。
售出了不存在的票，比如0和-1。

注意：
线程安全问题都是由全局变量及静态变量引起的，若每个线程中对全局变量、静态变量只有读操作，而无写操作，一般来说，这个全局变量是线程安全的；若有多个线程同时执行写操作，一般都需要考虑线程同步，否则的话就可能影响线程安全。
在这里插入图片描述

5 线程同步

当多个线程访问同一资源时，且多个线程对资源有写的操作，就容易出现线程安全问题。要解决上述过程并发访问一个资源的安全性问题：也就是解决重复票与不存在票问题，java中提供了同步机制（synchronized）来解决。
有三种方式完成同步操作：

同步代码块
同步方法
锁机制

同步原理如图：
在这里插入图片描述

5.1 同步代码块

synchronized关键字可以用于方法中的某个区块中，表示只对这个区块的资源实现互斥访问。

格式：

synchronized(同步锁){      
		需要同步操作的代码
		 }

同步锁：
对象的同步锁只是一个概念，可以想象为在对象上标记了一个锁。

锁对象可以是任意类型。
多个线程对象，要使用同一把锁。
在任何时候，最多允许一个线程拥有同步锁，谁拿到锁进入代码块，其他的线程只能在外等着(BLOCKED)。

代码运行如下:

package Demo07;

import Demo07.RunnableImpl;

public class Demo01Ticket {
    public static void main(String[] args) {
        //创建Runnable接口的实现类对象
        Runnable run = new RunnableImpl();
        //创建Thread类对象,构造方法中传递Runnable接口的实现类对象
        Thread t0 = new Thread(run);
        Thread t1 = new Thread(run);
        Thread t2 = new Thread(run);
        //调用start方法开启多线程
        t0.start();
        t1.start();
        t2.start();
    }
}
public class RunnableImpl implements Runnable{
    //定义一个多个线程共享的票源
    private int ticket = 100;

    //创建一个锁对象
    Object obj = new Object();

    //设置线程任务：买票
    @Override
    public void run(){
        //使用死循环，让卖票操作重复执行
        boolean flag = true;
        while (flag){
            //同步代码块
            synchronized(obj){
                //先判断票是否存在
                if(ticket>0){
                    try{
                        Thread.sleep(100);
                    }catch(InterruptedException e){
                        e.printStackTrace();
                    }

                    //票存在，卖票 ticket--
                    System.out.println(Thread.currentThread().getName()+"-->正在卖第"+ticket+"票");
                    ticket--;
                }
                else{
                   flag = false;
                }
            }
        }
    }
}

运行结果如图：
在这里插入图片描述

5.2 同步方法

使用synchronized修饰的方法，就叫做同步方法，保证A线程执行该方法的时候，其他线程只能在方法外等着。

格式：

public synchronized void main(){
      //可能会产生线程安全问题的代码
      }

代码运行如下：

/*
    模拟卖票案例
    创建3个线程,同时开启,对共享的票进行出售
 */
public class Demo01Ticket {
    public static void main(String[] args) {
        //创建Runnable接口的实现类对象
        RunnableImpl run = new RunnableImpl();
        System.out.println("run:"+run);
        //创建Thread类对象，构造方法中传递Runnable接口的实现类对象
        Thread t0 = new Thread(run);
        Thread t1 = new Thread(run);
        Thread t2 = new Thread(run);
        //调用start方法开启多线程
        t0.start();
        t1.start();
        t2.start();
    }
}

/*
    卖票案例出现了线程安全问题
    卖出了不存在的票和重复的票

    解决线程安全问题的二种方案:使用同步方法
    使用步骤:
        1.把访问了共享数据的代码抽取出来,放到一个方法中
        2.在方法上添加synchronized修饰符

    格式:定义方法的格式
    修饰符 synchronized 返回值类型 方法名(参数列表){
        可能会出现线程安全问题的代码(访问了共享数据的代码)
    }
 */
public class RunnableImpl implements Runnable{
    //定义一个多线程共享的票源
    private int ticket = 100;
    private  boolean flag = true;
    
    //设置买票线程任务：卖票
    @Override
    public void run() {
        System.out.println("this:"+this);
        //使用循环，让卖票操作重复执行

        while(flag){
            payTicket();
            System.out.println(ticket);
        }
    }

    private synchronized void payTicket() {

            //先判断票是否存在
            if(ticket > 0){
                //提高安全问题出现的概率，让程序睡眠
                try{
                    Thread.sleep(100);
                }catch (InterruptedException e){
                    e.printStackTrace();
                }

                //票存在，卖票，ticket--
                System.out.println(Thread.currentThread().getName()+"正在卖第"+ticket+"张票");
                ticket--;
            }
            else{
                flag = false;
                System.out.println(ticket);
            }
        }

}

运行部分结果如图：
在这里插入图片描述

同步锁是谁？
对于非static方法，同步锁就是this。
对于stctic方法，我们使用当前方法所在类的字节码对象（类名.class）。

代码如下：

public class RunnableImpl3 implements Runnable {
    //定义一个多线程共享的票源
    private int ticket = 100;
    private  boolean flag = true;

    //设置买票线程任务：卖票
    @Override
    public void run() {
        System.out.println("this:"+this);
        //使用循环，让卖票操作重复执行

        while(flag){
            payTicket();
            System.out.println(ticket);
        }
    }
    /*
        定义一个同步方法
        同步方法也会把方法内部的代码锁住
        只让一个线程执行
        同步方法的锁对象是谁?
        就是实现类对象 new RunnableImpl()
        也是就是this
     */
    private  void payTicket() {
        synchronized (this){
            //先判断票是否存在
            if(ticket > 0){
                //提高安全问题出现的概率，让程序睡眠
                try{
                    Thread.sleep(10);
                }catch (InterruptedException e){
                    e.printStackTrace();
                }

                //票存在，卖票，ticket--
                System.out.println(Thread.currentThread().getName()+"正在卖第"+ticket+"张票");
                ticket--;
            }
            else{
                flag = false;
                System.out.println(ticket);
            }
        }
    }
}

运行结果如图：
在这里插入图片描述

静态方法运行代码如下：

public class RunnableImpl2 implements Runnable{
    //定义一个多线程共享的票源
    private static int ticket = 100;
    private  static boolean flag = true;

    //设置买票线程任务：卖票
    @Override
    public void run() {
        System.out.println("this:"+this);
        //使用循环，让卖票操作重复执行

        while(flag){
            payTicketStatic();
            System.out.println(ticket);
        }
    }
    /*
            静态的同步方法
            锁对象是谁?
            不能是this
            this是创建对象之后产生的,静态方法优先于对象
            静态方法的锁对象是本类的class属性-->class文件对象(反射)
         */
  private static void payTicketStatic() {
        synchronized (RunnableImpl.class){
            //先判断票是否存在
            if(ticket > 0){
                //提高安全问题出现的概率，让程序睡眠
                try{
                    Thread.sleep(10);
                }catch (InterruptedException e){
                    e.printStackTrace();
                }

                //票存在，卖票，ticket--
                System.out.println(Thread.currentThread().getName()+"正在卖第"+ticket+"张票");
                ticket--;
            }
           else{
                flag = false;
                System.out.println(ticket);
            }
        }
    }
}

运行结果如图：
在这里插入图片描述

5.2 Lock锁

java.util.concurrent.locks.Lock机制提供了比synchronized代码块和synchronized方法更广泛的锁定操作，同步代码块/同步方法具有的功能Lock都有，除此之外更强大，更体现面向对象。

Lock锁也称同步锁，加锁与释放锁方法了，如下：

public void lock( ):加同步锁。
public void unlock( ):释放同步锁。

代码运行如下：

package Demo09;
/*
    模拟卖票案例
    创建3个线程,同时开启,对共享的票进行出售
 */
public class Demo01Ticket {
    public static void main(String[] args) {
        //创建Runnable接口的实现类对象
        RunnableImpl run = new RunnableImpl();
        //创建Thread类对象，构造方法中传递Runnable接口的实现类对象
        Thread t0 = new Thread(run);
        Thread t1 = new Thread(run);
        Thread t2 = new Thread(run);
        //调用start方法开启多线程
        t0.start();
        t1.start();
        t2.start();
    }
}

/*
    卖票案例出现了线程安全问题
    卖出了不存在的票和重复的票

    解决线程安全问题的三种方案:使用Lock锁
    java.util.concurrent.locks.Lock接口
    Lock 实现提供了比使用 synchronized 方法和语句可获得的更广泛的锁定操作。
    Lock接口中的方法:
        void lock()获取锁。
        void unlock()  释放锁。
    java.util.concurrent.locks.ReentrantLock implements Lock接口


    使用步骤:
        1.在成员位置创建一个ReentrantLock对象
        2.在可能会出现安全问题的代码前调用Lock接口中的方法lock获取锁
        3.在可能会出现安全问题的代码后调用Lock接口中的方法unlock释放锁
 */
public class RunnableImpl implements Runnable{
    //定义一个多线程共享的票源
    private int ticket = 100;
    private boolean flag = true;

    //1.在成员位置创建一个ReentrantLock对象
    Lock l = new ReentrantLock();

    //设置线程任务：卖票
    @Override
    public void run() {
        //使用循环，让卖票操作重复执行
        while(flag){
            //2.在可能会出现安全问题的代码前调用Lock接口中的方法lock获取锁
            l.lock();

            //先判断票是否存在
            if(ticket > 0){
               //提高安全问题出现的概率，让程序睡眠
                try{
                    Thread.sleep(100);
                    //票存在，卖票，ticket--
                    System.out.println(Thread.currentThread().getName()+"-->正在卖第"+ticket--+"张票");
                }catch (InterruptedException e){
                    e.printStackTrace();
                }
                finally{
                    //3.在可能会出现安全问题的代码后调用Lock接口中的方法unlock释放锁
                    l.unlock();//无论程序是否异常,都会把锁释放
                }
            }
            else{
                flag = false;
            }
        }
    }

运行结果如图：
在这里插入图片描述

6 线程状态

在这里插入图片描述

6.1 等待唤醒机制

多个线程并发执行时，在默认情况下CPU是随机切换线程的，当需要多个线程来共同完成一件任务，并且希望它们有规律的执行，那么多线程之间需要一些协调通信，一次来达到多线程共同操作一份数据。

多个线程在处理同一资源，并且任务不同时，需要线程通信来帮助解决线程之间对同一个变量的使用或操作，就是多个线程在操作同一份数据时，避免对同一共享变量的争夺。也就是我们需要通过一定的手段使各个线程能有效的利用资源，而这种手段就是——等待唤醒机制。

等待唤醒机制就是用于解决线程间通信的问题的，使用的3个方法的含义如下：

wait：线程不再活动，不再参与调度，进入wait set中，因此不会浪费CPU资源，也不会竞争锁，这时的线程状态即是WAITING。它还要等着别的线程执行一个特别的动作，也即是“通知(notify)”在这个对象上等待的线程从wait set中释放出来，重新进入调度队列(ready queue)中。
notify：则选取所通知对象的wait set中的一个线程释放，例如。餐馆有空位置后，等待就餐最久的顾客最先入座。
notifyAll：则释放所通知对象的wait set上的全部线程。

注意：
（1）哪怕只通知了一个等待的线程，被通知的线程也不能立即恢复执行，因为它当初中断的地方是在同步块内，而此刻它已经不持有锁，所有它需要再次尝试去获取锁（很可能面临其他线程的竞争），成功后才能在当初调用wait方法之后的地方恢复执行。

（2） wait方法与notify方法必须由同一个锁对象调用。因为：对应的锁对象可以通过notify唤醒使用同一个锁对象调用的wait方法后的线程。

（3）wait方法与notify方法是属于Object类的方法的，因为：锁对象可以是任意对象，而任意对象的所属类都是继承了Object类的。

（4）wait与notify方法必须要在同步代码块或者是同步函数中使用。因为：必须要通过锁对象调用这2个方法。

6.2 生产者与消费者问题

包子铺线程生产包子，吃货线程消费包子。当包子没有时（包子状态为false），吃货线程等待，包子铺线程生产包子（即包子状态为true），并通知吃货线程（解除吃货的等待状态）,因为已经有包子了，那么包子铺线程进入等待状态。接下来，吃货线程能否进一步执行则取决于锁的获取情况。如果吃货获取到锁，那么就执行吃包子动作，包子吃完（包子状态为false），并通知包子铺线程（解除包子铺的等待状态）,吃货线程进入等待。包子铺线程能否进一步执行则取决于锁的获取情况。

在这里插入图片描述

代码运行如下：

package Demo01;

public class WaitAndNotify {
    public static void main(String[] args) {
        //等待唤醒案例
        BaoZi bz = new BaoZi();

        ChiHuo ch = new ChiHuo(bz);
        BaoZiPu bzp = new BaoZiPu(bz);

        ch.start();
        bzp.start();
    }
}

public class BaoZi {
    String pier;
    String xianer;
    boolean flag = false; //包子资源是否存在
}

public class BaoZiPu extends Thread{
    private BaoZi bz;

    public BaoZiPu(BaoZi bz) {

        this.bz = bz;
    }

    @Override
    public void run() {
        System.out.println("包子铺线程");
        int count = 0;
        //造包子
        while(true){
            //同步
            synchronized (bz){
                if(bz.flag == true){//包子资源存在
                    try{
                        bz.wait();
                    }catch (InterruptedException e){
                        e.printStackTrace();
                    }
                }
                //没有包子，开始造包子
                System.out.println("包子铺开始做包子");
                if(count%2 == 0 ){
                    //冰皮  五仁
                    bz.pier = "冰皮";
                    bz.xianer = "五仁";
                }else{
                    //薄皮  牛肉大葱
                    bz.pier = "薄皮";
                    bz.xianer = "牛肉大葱";
                }
                count++;

                bz.flag = true;
                System.out.println("包子造好了："+bz.pier + bz.xianer);
                System.out.println("吃货来吃吧");
                System.out.println("========================");
                //唤醒等待线程（吃货）
                bz.notify();
            }
        }
    }
}

public class ChiHuo extends Thread{
    private BaoZi bz;

    public ChiHuo(BaoZi bz){

        this.bz = bz;
    }

    @Override
    public void run() {
        System.out.println("吃货线程");
        while(true){
            synchronized (bz){
                if(bz.flag == false){//没包子
                    try{
                        bz.wait();
                    }catch (InterruptedException e){
                        e.printStackTrace();
                    }
                }
                System.out.println("吃货正在吃"+bz.pier + bz.xianer +"包子");
               try {
                    Thread.sleep(1000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                System.out.println("-----------------------------------------");
                bz.flag = false;
                bz.notify();
            }
        }
    }
}

运行结果如图：
在这里插入图片描述

7 线程池

线程池：其实就是一个容纳多个线程的容器，其中的线程可以反复使用，省去了频繁创建线程对象的操作，无需反复创建线程而消耗过多资源。

在这里插入图片描述
合理利用线程池能够带来三个好处：

降低资源消耗。减少了创建和销毁线程的次数，每个工作线程都可以被重复利用，可执行多个任务。
提高响应速度。当任务到达时，任务可以不需要的等到线程创建就能立即执行。
提高线程的可管理性。可以根据系统的承受能力，调整线程池中工作线线程的数目，防止因为消耗过多的内存，而把服务器累趴下(每个线程需要大约1MB内存，线程开的越多，消耗的内存也就越大，最后死机)。

7.1 线程池的使用

Java里面线程池的顶级接口是java.util.concurrent.Executor，但是严格意义上讲Executor并不是一个线程池，而只是一个执行线程的工具。真正的线程池接口是java.util.concurrent.ExecutorService。

要配置一个线程池是比较复杂的，尤其是对于线程池的原理不是很清楚的情况下，很有可能配置的线程池不是较优的，因此在java.util.concurrent.Executors线程工厂类里面提供了一些静态工厂，生成一些常用的线程池。官方建议使用Executors工程类来创建线程池对象。

Executors类中有个创建线程池的方法如下：

public static ExecutorService newFixedThreadPool(int nThreads)：返回线程池对象。(创建的是有界线程池,也就是池中的线程个数可以指定最大数量)

获取到了一个线程池ExecutorService 对象，那么怎么使用呢，在这里定义了一个使用线程池对象的方法如下：

public Future<?> submit(Runnable task):获取线程池中的某一个线程对象，并执行

Future接口：用来记录线程任务执行完毕后产生的结果。线程池创建与使用。

使用线程池中线程对象的步骤：

创建线程池对象。
创建Runnable接口子类对象。(task)
提交Runnable接口子类对象。(take task)
关闭线程池(一般不做)。

代码运行如下：

/*
    线程池:JDK1.5之后提供的
    java.util.concurrent.Executors:线程池的工厂类,用来生成线程池
    Executors类中的静态方法:
        static ExecutorService newFixedThreadPool(int nThreads) 创建一个可重用固定线程数的线程池
        参数:
            int nThreads:创建线程池中包含的线程数量
        返回值:
            ExecutorService接口,返回的是ExecutorService接口的实现类对象,我们可以使用ExecutorService接口接收(面向接口编程)
    java.util.concurrent.ExecutorService:线程池接口
        用来从线程池中获取线程,调用start方法,执行线程任务
            submit(Runnable task) 提交一个 Runnable 任务用于执行
        关闭/销毁线程池的方法
            void shutdown()
    线程池的使用步骤:
        1.使用线程池的工厂类Executors里边提供的静态方法newFixedThreadPool生产一个指定线程数量的线程池
        2.创建一个类,实现Runnable接口,重写run方法,设置线程任务
        3.调用ExecutorService中的方法submit,传递线程任务(实现类),开启线程,执行run方法
        4.调用ExecutorService中的方法shutdown销毁线程池(不建议执行)
 */

import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;

public class Demo01ThreadPool {
    public static void main(String[] args) {
        //1.使用线程池的工厂类Executors里边提供的静态方法newFixedThreadPool生产一个指定线程数量的线程池
        ExecutorService es = Executors.newFixedThreadPool(2);
        //3.调用ExecutorService中的方法submit,传递线程任务(实现类),开启线程,执行run方法
        es.submit(new RunnabeImpl());//pool-1-thread-1创建了一个新的线程执行
        //线程池会一直开启,使用完了线程,会自动把线程归还给线程池,线程可以继续使用
        es.submit(new RunnabeImpl());//pool-1-thread-1创建了一个新的线程执行
        es.submit(new RunnabeImpl());//pool-1-thread-2创建了一个新的线程执行

        //4.调用ExecutorService中的方法shutdown销毁线程池(不建议执行)
        es.shutdown();
        //es.submit(new RunnableImpl());//抛异常,线程池都没有了,就不能获取线程了
    }
}

public class RunnabeImpl implements Runnable {
    @Override
    public void run() {
        System.out.println(Thread.currentThread().getName()+"-->创建了一个新线程执行");
    }
}

运行结果如下：
在这里插入图片描述

谢晓永

关注

0
点赞
踩
1

收藏

觉得还不错? 一键收藏
0
评论
java之多线程总结

1 概念操作系统的基本特征包括并发、共享、虚拟和异步。1.并发操作系统的并发性是指计算机系统中同时存在多个运行着的程序，因此它具有处理和调度多个程序同时执行的能力，引入进程的目的是使程序能并发执行。并发：指两个事件或多个事件在同一个时间段内发生。并行：指两个或多个事件在同一时刻发生（同时发生）。2.共享资源共享即共享，是指系统中的资源可供内存中多个并发执行的进程共同使用，共享可分为以下两种资源共享方式。（1）互斥共享方式当进程A访问某资源时，必须先提出请求，如果此时资源空闲，系统便可以将之
复制链接

扫一扫

专栏目录