十一、线程与线程间通信

最新推荐文章于 2024-08-26 22:21:43 发布

吃蜡笔的小新

最新推荐文章于 2024-08-26 22:21:43 发布

阅读量912

点赞数

分类专栏： JAVASE 文章标签： java 后端

本文链接：https://blog.csdn.net/Ningmengyouzhi/article/details/123258905

版权

JAVASE 专栏收录该内容

12 篇文章 0 订阅

订阅专栏

写代码时遇到一个以前错误的理解，记录一下

当一个文件中存在多个类，public 修饰的类只能有一个，但含有主方法的类可以有多个或者没有，且不一定存在public类中，若含有多个主类，只执行一个主类，每个主类都有可能执行，但前遇到的主类执行可能性较大

class test1{
    public static void main(String[] args) {
        System.out.println(1);
    }
}
public class test {
    public static void main(String[] args) {
        System.out.println(2);
    }
}
//经过很多次的运行，出现1的次数比较多，偶尔也会输出2，
//具体原因还不清楚，慢慢学吧

线程

一、线程中的基本概念

程序：软件开发，写代码的。为了完成特定任务，用某种语言编写的一组指令的集合。是一段静态的代码，静态对象。
进程：动态的过程，程序运行了，就会产生进程。
程序的一次执行的过程。
会有自己的产生，存在，消亡的过程。
程序静态的
进程动态的
进程在运行的时候，电脑为每个进程分配不同的内存区域。
线程：线程是程序的执行单元。是程序使用CPU的最基本单位。一个进程的执行，是靠线程来走的。
程序可以进一步细化为线程，是一个程序内部的一条执行路径。若一个进程同一时间并行执行多个线程，就是支持多线程的。线程做为调度和执行的单位，每个线程拥有独立的运行栈和程序计算器，线程切换的开销小。一个进程中的多个线程共享相同的内存单元|内存地址。他们从同一堆中分配对象，可以访问相同的变量和对象。这就使得线程间通信更简洁，高效。但多个线程操作共享的系统资源可能会带来安全隐患。
单核CPU和多核CPU：单核CPU，其实是一种假的多线程。因为再一个时间单元内，也只能执行一个线程的任务。因为CPU时间单元特别短，因此感觉不出来。多核的话，才能更好的发挥多线程的效率。一个java程序java.exe,至少三个线程main()主线程，gc()垃圾回收线程，异常处理线程。如果发生异常，会影响主线程。
并行域并发：并行：多个CPU同时执行多个任务。也就是多人同时做不同的事情。
并发：一个CPU(采用时间片)同时执行多个任务。比如，秒杀，多人做同一件事。
多线程的优点：以单核CPU为例，只使用单个线程先后完成多个任务（调用多个方法），肯定比用多个线程来完成用的时间更短，为何仍徐多线程呢？多线程的优点：1>提供应用程序的响应，对图形化界面更有意义，可增强用户体验。提供计算机系统CPU的利用率。改善程序结构，将既长又复杂的进程分为多个线程，独立运行，利用理解和修改。
什么时候需要多线程呢？
程序需要同时执行两个或多个任务。
程序需要实现一些需要等待的任务时，如用户输入，文件读写操作，网络操作，搜索等。
需要一些后台执行的程序时。
之前的代码都是单线程的。

二、线程的创建和使用

方式一:Thread类

package 线程.demo01;

public class MyThread extends Thread{//自己写一个类需要继承Thread类
    @Override
    public void run() {//重写这个run方法
        for (int i=1;i<=5;i++){
          //  System.out.println(Thread.currentThread().getName()+":"+i);和下面是一样的意思，如果没有继承的话就只能用这样的形式
            System.out.println(getName()+":"+i);//Thread会自动分配名字Thread-0、Thread-1...
        }
    }

    public MyThread(String name) {//可以在创建的时候，传进去一个线程名字
        super(name);
    }

    public MyThread() {
    }
}

class MyThreadTest{
    public static void main(String[] args) {
        MyThread thread = new MyThread();
        thread.start();//启动线程必须的start
       //  thread.start();线程不能多次启动
        MyThread thread1 = new MyThread();
     //   thread1.setName("线程2");可以自己给该线程起名字
        thread1.start();

        for (int i=1;i<=5;i++){
            System.out.println(Thread.currentThread().getName()+":"+i);//主方法也会有自己的名字
        }
    }
}

我们看一下运行效果

main:1
Thread-0:1
Thread-0:2
Thread-0:3
Thread-0:4
Thread-0:5
Thread-1:1
main:2
Thread-1:2
main:3
Thread-1:3
main:4
Thread-1:4
main:5
Thread-1:5
如果要是按照我们以前的理解那么执行结果不是这样的，应该是先出现的内容执行完，在执行后出现的内容。
所以根据运行结果可以理解，多线程一样开启，就会争抢CPU运行，比如mian抢到了机会，就运行，然后Thread-0抢到了机会就运行..

Thread类的特点：每个线程都说通过某个特定的Thread对象的run()方法来完成操作的，经常把run() 方法的主体称为线程体。我们再使用的时候，是通过调用start()方法来启动这个线程的。一个线程对象只能调用一次start()方法启动线程。如果重复调用就会抛出异常"IllegalThreadStateException"

方式二：实现Runnable接口

package 线程.demo01;

public class MyRunnable implements Runnable{

    @Override
    public void run() {
        for (int i=1;i<=100;i++){
            try {
                if(Thread.currentThread().getName().equals("线程1")&&i%20==0){
                    Thread.sleep(1000);//线程1睡眠1秒，在线程一睡眠期间，其他线程会争抢CPU运行
                    //即转为阻塞，睡眠结束后转为就绪状态
                }
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println(Thread.currentThread().getName()+":"+i);
        }
    }
}
class MyRunnableTest{
    public static void main(String[] args) {
        MyRunnable runnable = new MyRunnable();
        Thread thread = new Thread(runnable);
        thread.setName("线程1");
        Thread thread1 = new Thread(runnable);
        thread1.setName("线程2");

        thread.start();
        thread1.start();

        for (int i=1;i<=100;i++){
            System.out.println(Thread.currentThread().getName()+":"+i);
        }
    }
}

三、线程状态

根据上面的代码，我们可以理解为一下运行状态

新建(new)–>就绪(start)–>运行(争抢CPU)–>(可能存在阻塞，比如sleep睡眠)–>死亡

新建(New)：在程序中用构造方法创建了一个线程对象后，新的线程对象便处于新建状态，此时，他已经有了相应的内存空间和其他资源，但还不处于可运行状态。

就绪(Runnable)：新建线程对象后，可调用线程的start()方法就可以启动线程。当线程启动时，线程进入就绪状态。此时，线程将进入线程队列排队，等待CPU服务，这表名他已经具备了运行条件

运行(Running)：当就绪状态的线程被调用并获得处理器资源时，线程就进入了运行状态。此时，自动调用该线程对象的run()方法。run()方法定义了该线程的操作和功能。

阻塞(Blocked)：一个正在执行的线程在某些特殊情况下，如被认为挂起或需要执行耗时的输入/ 输出操作时，会让出CPU并暂时终止自己的行为，进入堵塞状态，在可执行状态下，如果调用 sleep(),suspend().wait()等方法，线程将进入堵塞状态。堵塞时，线程不能进入排队队列，只有当引起堵塞的原因被消除后，线程才可以转入就绪状态。线程调用了sleep()方法主动放弃所占用的处理器资源。线程调用了一个阻塞式IO方法,在该方法返回之前,该线程被阻塞。线程试图获得一个同步监视器,但该同步监视器正被其它线程所持有。线程在等待某个通知(notify)。

死亡(Dead)：线程调用stop()方法时或run()方法执行结束后，处于死亡状态。处于死亡状态的线程不具备继续运行的能力。

常见方法

join方法

package 线程.demo02;

public class MyThread extends  Thread{
    @Override
    public void run() {
        for(int i=1;i<=100;i++){
            System.out.println(getName()+":"+i);
        }
    }
}

class MyThreadTest{
    public static  void  main(String[] args){
        MyThread th1 = new MyThread();
        th1.setName("线程1");
        MyThread th2 = new MyThread();
        th2.setName("线程2");
        MyThread th3 = new MyThread();
        th3.setName("线程3");

        th1.start();
        try {
            th1.join();//等待该线程运行结束后 ，其他线程开始运行。
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        th2.start();
        th3.start();


        for(int i=1;i<=100;i++){
            System.out.println(Thread.currentThread().getName()+":"+i);
        }
    }
}

sleep方法

在指定的毫秒数内让当前正在执行的线程休眠（暂停执行），此操作受到系统计时器和调度程序精度和准确性的影响。该线程不丢失任何监视器的所属权。

代码上面讲过了，就不重复讲解

Interrupt 方法

package 线程.demo02;

import java.util.Date;

public class MyRunnable implements  Runnable{
    @Override
    public void run() {
        System.out.println("开始执行:"+new Date());
        try {
            Thread.sleep(10000);
        } catch (InterruptedException e) {
            System.out.println("线程被打断");
        }
        System.out.println("结束:"+new Date());//正常来说，开始与结束时间间隔10秒中的，
    }
}

class MyThread2Test {
    public static void main(String[] args) {
        MyRunnable runnable = new MyRunnable();
        Thread thread = new Thread(runnable);
        thread.start();
        try {
            Thread.sleep(2000);//在两秒的时候，去打断线程
            thread.interrupt();//打断线程
        } catch (InterruptedException e) {
            e.printStackTrace();
        }


    }
}

yield方法

暂停当前正在执行的线程对象，并执行其他线程。yield()应该做的是让当前运行线程回到可运行状态，以允许具有相同优先级的其他线程获得运行机会。因此，使用yield()的目的是让相同优先级的线程之间能适当的轮转执行。但是，实际中无法保证yield()达到让步目的，因为让步的线程还有可能被线程调度程序再次选中。

package 线程.demo02;

public class MyRunable2 implements  Runnable{
    @Override
    public void run() {
        for(int i=1;i<=100;i++){
            System.out.println(Thread.currentThread().getName()+":"+i);
        }
    }
}

class  MyRunable2Test{
    public static void main(String[] args) {
        MyRunable2 runable2 = new MyRunable2();
        Thread thread = new Thread(runable2);
        thread.start();
        for(int i=1;i<=100;i++){
            System.out.println(Thread.currentThread().getName()+":"+i);
            Thread.yield();//主方法进行让步，但是虽然让步了，该线程还有可能被cpu选中继续执行
        }
    }
}
//可能看不出来，但整体上，主方法会让其他线程先执行

优先级

线程默认优先级是5，可以自己设置线程的优先级。通过，setPriority()方法来设置线程的优先级。优先级的范围是1-10.线程优先级高仅仅表示线程获取CPU时间片的几率高，只是几率比较高，但是要在次数比较多，或者多此运行时才能看比较好的效果。

线程分为两类，一类是守护线程，一类是用户线程。他们在几乎每个方面都说相同的，唯一的区别是判断JVM何时离开。守护线程是用来服务用户线程的。通过在start()方法前调用 thread.setDaemon(true)可以把一个用户线程变成守护线程。Java垃圾回收就是一个典型的守护线程。弱JVM中都是守护线程，当前JVM将退出。

package 线程.demo02;

public class MyRunable3  implements  Runnable{
    @Override
    public void run() {
        for(int i=1;i<=100;i++){
            System.out.println(Thread.currentThread().getName()+":"+i);
        }
    }
}
class  MyRunable3Test {
    public static void main(String[] args) {
        MyRunable3 runable3 = new MyRunable3();
        Thread th1 = new Thread(runable3,"线程1");
        Thread th2 = new Thread(runable3,"线程2");
        Thread th3 = new Thread(runable3,"线程3");
        th1.setPriority(10);//设置优先级
        th3.setPriority(1);
        th1.start();
        th2.start();
        th3.start();
    }
}

同步与死锁

现在学了多线程，那么存在这样一个问题。如下一段代码，是一买票的系统，但分为好几个窗口买同一种票。所以当这个窗口卖出一张票，其他窗口就要接收到该信息。

我们现在考虑这样一个问题，当最后还有一张票时，首先窗口1抢到CPU执行到if (nums>0)这一行并完成判断，这时窗口2抢到了CPU也执行到这一行，nums还是1，这时窗口3同样抢到了，nums还是1。三个窗口同时完成if判断，那么他们往后执行的时候，三个窗口都会买票所以同一张票可能卖出多次，也可能出现负票。这时就需要同步与死锁。

package 线程.demo03;

public class Tickets implements  Runnable{
    int nums=100;//一共60张票

    @Override
    public void run() {
        if (nums>0){
            System.out.println("卖出第"+nums+"张票");
            nums--;
        }else{
            System.out.println("票已经买完");
        }
    }
}

class  TicketsTest{
    public static void main(String[] args) {
        Tickets run = new Tickets();
        Thread th1 = new Thread(run,"窗口1");
        Thread th2 = new Thread(run,"窗口2");
        Thread th3 = new Thread(run,"窗口3");

        th1.start();
        th2.start();
        th3.start();
    }
}

synchronized关键字

就是把一段代码锁在一起，必须一起执行

同步监视器：俗称，锁。任何一个类的对象，都可以充当锁，但是要去必须多个线程公用一把锁。

接下来这段代码就不会存在这样的问题

这是把对象做一个同步监视

package 线程.demo03;

public class Tickets implements    Runnable{
    int nums=100;//一共60张票

    @Override
    public void run() {
        while(true){
            try {
                Thread.sleep(1000);
                synchronized (this){//把这个对象进行同步，里面的代码必须一起执行，这样就不会存在买同一张票了
                    if(nums<=0){
                        break;
                    }
                    System.out.println(Thread.currentThread().getName()+"在售第"+nums+"张票");
                    nums--;
                }
            } catch (InterruptedException e) {
                e.printStackTrace();
            }


        }
    }
}

class  TicketsTest{
    public static void main(String[] args) {
        Tickets run = new Tickets();//接下来操作的都是这一个对象，所以上面对对象同步
        Thread th1 = new Thread(run,"窗口1");
        Thread th2 = new Thread(run,"窗口2");
        Thread th3 = new Thread(run,"窗口3");

        th1.start();
        th2.start();
        th3.start();
    }
}

这是把类做一个同步监视

package 线程.demo04;

public class Tickets extends Thread {
    static int nums = 60;

    @Override
    public void run() {

         show();

    }

    public static void show() {
        while (true) {
            try {
                Thread.sleep(1000);
                synchronized (Tickets.class){//对这个类进行同步监视
                    if (nums <= 0) {
                        break;
                    }
                    System.out.println(Thread.currentThread().getName() + "在售第" + nums + "张票");
                    nums--;
                }
            } catch (InterruptedException e) {
                e.printStackTrace();
            }

        }

    }

}

class Tickets2Test{
    public static void main(String[] args) {
        //这里操作的时不同的对象，但他们时同一个类，所以上面对类加锁
        Tickets wind = new Tickets();
        wind.setName("窗口1");
        Tickets wind2 = new Tickets();
        wind2.setName("窗口2");
        Tickets wind3 = new Tickets();
        wind3.setName("窗口3");

        wind.start();
        wind2.start();
        wind3.start();
    }
}

单例模式

单线程单例模式

package 线程.demo05;

public class Singleton {
    static  Singleton singleton = new Singleton();//饿汉模式
    public static  Singleton getInstace(){
        return  singleton;
    }

    private  Singleton(){

    }
}

class  SingletonTest{
    public static void main(String[] args) {
        Singleton s1 = Singleton.getInstace();
        Singleton s2 = Singleton.getInstace();
        Singleton s3 = Singleton.getInstace();
        System.out.println(s1);
        System.out.println(s2);
        System.out.println(s3);
    }
}

在单线程下是可以实现单例模式的，当应用在多线程下就存在问题，也是同时的问题

多线程单例模式

package 线程.demo06;

public class Singleton {
    static  Singleton singleton ;//懒汉模式
    public synchronized static  Singleton getInstace(){
        if(singleton==null){
            singleton = new Singleton();
        }
        return  singleton;
    }

    private  Singleton(){

    }
}

class  SingletonTest{
    public static void main(String[] args) {
        Singleton s1 = Singleton.getInstace();
        Singleton s2 = Singleton.getInstace();
        Singleton s3 = Singleton.getInstace();
        System.out.println(s1);
        System.out.println(s2);
        System.out.println(s3);
    }
}

package 线程.demo07;

public class Singleton {
    static  Singleton singleton ;//懒汉模式
    public  static  Singleton getInstace(){
       if(null==singleton){
           synchronized (Singleton.class){//对类进行同步监视
               if(singleton==null){
                   singleton = new Singleton();
               }
           }
       }
        return  singleton;
    }

    private  Singleton(){

    }
}

class  SingletonTest{
    public static void main(String[] args) {
        Singleton s1 = Singleton.getInstace();
        Singleton s2 = Singleton.getInstace();
        Singleton s3 = Singleton.getInstace();
        System.out.println(s1);
        System.out.println(s2);
        System.out.println(s3);
    }
}

以上一个是对方法进行监视，一个是对代码块进行监视，适用于多线程

同步的特点：前提：多个线程。

解决问题的时候要注意:多个线程使用的是同一个锁对象。

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

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

synchronized：同步，需要被同步的代码。

同步方法，仍然需要同步监视器，只是不需要显示声明。

非静态的同步方法，同步监视器是this 。

静态的同步方法，同步监视器是当前类本身。

死锁

死锁 : 不同的线程分别占用对方需要的同步资源不放弃，都在等待对方放弃自己需要的同步资源，就形成了死锁。出现死锁后，不会出现异常，不会出现提升，只是所有的线程都处于阻塞状态，无法继续。解决办法：专门的算法，原则。尽量减少同步资源的定义，尽量避免嵌套同步。

不太好理解，直接理解这段代码

首先创建一个类，很简单的一个类，存在两个静态成员变量

synchronized锁

package 线程.demo08;

public class Resources {
    public  static String s1="hello";
    public  static String s2="world";

}

接下来创建两个类，在这两个类中创建上面的那个类

package 线程.demo08;

public class MyThead1 implements  Runnable {
    @Override
    public void run() {
        while(true){

            try {
                synchronized (Resources.s1){
                    System.out.println("MyThread1持有了s1的锁");
                  Thread.sleep(100);
                    synchronized (Resources.s2){
                        System.out.println("MyThread1持有了s2的锁");
                    }
                }
            } catch (InterruptedException e) {
                e.printStackTrace();
            }

        }
    }
}

package 线程.demo08;

public class MyThread2 implements Runnable {
    @Override
    public void run() {
        while (true) {

            try {
                synchronized (Resources.s2) {
                    System.out.println("MyThread2持有了s2的锁");
                    Thread.sleep(100);
                    synchronized (Resources.s1) {
                        System.out.println("MyThread2持有了s1的锁");
                    }
                }
            } catch (InterruptedException e) {
                e.printStackTrace();
            }

        }
    }
}

可以看到MyThead1在多线程中先给s1加了锁，然后又给s2加了锁，MyThead2也加了锁，但顺序相反。多线程我们已经了解，如果这两个类的对象同时start，存在这样的情况，MyThead1对象抢到CPU执行到System.out.println(“MyThread1持有了s1的锁”);这一句，然后MyThead2对象抢到CPU开始执行到System.out.println(“MyThread2持有了s2的锁”);这一句，那么再往下执行时，到了synchronized (Resources.s1) 这一句，但s1的锁被MyThead1所持有，MyThead2不能进入，同理MyThead1再往下执行到synchronized (Resources.s2)这一句时，s2的锁被MyThead2所持有，不能进入，这是两个对象就会一直等待，形成死锁。

测试代码

package 线程.demo08;

public class Test {
    public static void main(String[] args) {
        MyThead1 run = new MyThead1();
        Thread th1 = new Thread(run);

        MyThread2 run2 = new MyThread2();
        Thread th2 = new Thread(run2);

        th1.start();
        th2.start();
    }
}

理解了之后，那么该如何避免死锁呢？

加锁顺序（线程按照一定的顺序加锁）。加锁时限（线程尝试获取锁的时候加上一定的时限，超过时限则放弃对该锁的请求，并释放自己占有的锁）。死锁检测。就像上面，说如果两个类的枷锁顺序相同时，就不会存在死锁情况。

Lock(锁)

从JDK5.0开始，java提供了更强大的线程同步机制。通过显示定义同步锁对象来实现同步。同步锁使用Lock对象充当。该接口是控制多个线程对共享资源进行访问的公交。锁提供了对共享资源的独占访问，每次只能有一个线程对Lock对象加锁，线程开始访问共享资源之前应先获得Lock对象。 ReentrantLock类实现了Lock接口，他拥有与synchronized相同的并发性盒内存语义，再实现线程安全的控制中，比较常用的RenntrantLock可以显示的加锁和释放锁。

我们一般还是使用synchronized，所以这个就简单介绍一下，接下来这段代码还是买票的例子

package 线程.demo08;

import java.util.concurrent.locks.ReentrantLock;

class Window implements Runnable{
    private int ticket = 100;
    private ReentrantLock lock = new ReentrantLock();//1.实例化ReentrantLock
    @Override
    public void run() {
        while(true){
            try {
                Thread.sleep(50);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            try{
                lock.lock();//2.调用锁定方法lock()
                if(ticket > 0){
                    System.out.println(Thread.currentThread().getName() +
                            "：售票，票号为：" + ticket);
                    ticket--;
                }else{
                    break;
                }
            }finally {
                lock.unlock();//3.调用解锁方法：unlock()
            }
        }
    }
}

public class LockTest {
    public static void main(String[] args) {
        Window w = new Window();
        Thread t1 = new Thread(w);
        Thread t2 = new Thread(w);
        Thread t3 = new Thread(w);
        t1.setName("窗口1");
        t2.setName("窗口2");
        t3.setName("窗口3");
        t1.start();
        t2.start();
        t3.start();
    }

}

可以看出使用lock需要手动锁定，手动解锁。

ynchronized与lock的异同

二者都可以解决线程安全问题。synchronized机制再执行完相应的同步代码以后，自动的释放同步监视器。Lock需要手动的启动同步（lock()），同时结束同步也需要手动的实现（unlock()）。

线程之间的通信

这几个方法先留个印象，主要看下面的代码，再理解这些方法的意思

wait方法，一旦执行，线程进入阻塞状态，并释放对象的锁。

notify方法，一旦执行，会唤醒等待的线程，如果有多个线程，唤醒优先级高的

notifyAll方法，会唤醒所有等待的线程。这三个方便必须再同步方法或同步代码块中使用。

sleep和wait方法的异同？

相同点：一旦执行方法，都可以使得当前的线程进入阻塞状态。

不同点：两个方法声明的位置不同，Thread中是sleep方法。Object类中是wait方法。

调用的范围不同：sleep方法可以再任何需要的场景下调用。wait必须在同步代码块中运行。

如果两个方法都用在同步代码块或同步方法中，sleep不会释放对象锁。wait方法会释放锁。

先理解一下这段代码

package 线程.Demo09;

public class PrintNum implements Runnable{
    static int i=1;
    @Override
    public void run() {
        while(true){
            try {
                Thread.sleep(100);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            synchronized (this){
                this.notify();//其他线程进入之后，释放上一个等待的线程
                if(i>100){
                    break;
                }
                System.out.println(Thread.currentThread().getName()+":"+i);
                i++;
                try {
                    this.wait();//该线程等待，并且释放锁，其他线程可以进入
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        }
    }
}
class PrintNumTest{
    public static void main(String[] args) {
        PrintNum run = new PrintNum();
        Thread th1 = new Thread(run,"线程1");
        Thread th2 = new Thread(run,"线程2");
        Thread th3 = new Thread(run,"线程3");
        th1.start();
        th2.start();
        th3.start();
    }
}

生产者与消费者

存在这样一个问题：

生产者生产一个产品，然后消费者可以得到商品，如果消费者没拿到生产的产品，生产者就不会生产，只有消费者得到商品后，生产者才会再次生产

package 线程.Demo09.生产者与消费者;

public class Factory {
    int[] arr = new int[1];//生产者生产的物品放入该数组中，消费者从该数组中取值
    int index = 0;//记录生产者生产一个，或消费者消费一个
    //1.生产东西
    public synchronized void setProduct(int num) {
        try {
            if(index==1) {//生产者已经生产，但是消费者未消费
                this.wait(3000);
            }
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        //只有两种情况会走到这里，1：生产者还未生产、2：生产者生产了，进入等待，然后被消费者唤醒后(即消费者购买了产品)
        arr[0]=num;//生产的东西保存，以便消费者消费
        System.out.println("生产者生产:"+arr[0]);
        this.notify();//通知消费者消费，唤醒上一步，即消费者
        index++;
    }
    //2.取东西
    public synchronized void getProduct() {
        try {
            if(index==0) {
                this.wait();//如果发现index==0说明还未生产好，需要等待
            }
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println("消费者消费:"+arr[0]);
        index--;
//this.notify();//通知生产者生产
    }
}

class Product extends Thread{
    Factory factory = null;
    public Product(Factory factory) {
        super();
        this.factory = factory;
    }
    @Override
    public void run() {
        for(int i=1;i<=10;i++) {
            factory.setProduct(i);
        }
    }
}
class Customer extends Thread {
    Factory factory = null;
    public Customer(Factory factory) {
        super();
        this.factory = factory;
    }
    @Override
    public void run() {
        for(int i=1;i<=10;i++) {
            factory.getProduct();
        }
    }
}
class Test {
    public static void main(String[] args) {
        Factory fa = new Factory();
        Product p = new Product(fa);
        p.start();
        Customer c = new Customer(fa);
        c.start();
    }
}

实现Callable接口

和Runnable接口差不多，但Runnable接口中的run是void无返回值的，而Callable接口中的方法是有返回值的。

package 线程.Demo09;

import java.util.concurrent.Callable;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.FutureTask;

//1.创建一个实现Callable的实现类
class NumThread implements Callable {
    //2.实现call方法，将此线程需要执行的操作声明在call()中
    @Override
    public Object call() throws Exception {
        int sum = 0;
        for (int i = 1; i <= 100; i++) {
            if(i % 2 == 0){
                System.out.println(i);
                sum += i;
            }
        }
        return sum;//存在一个返回值
    }
}
public class ThreadNewTest {
    public static void main(String[] args) {
        //3.创建Callable接口实现类的对象
        NumThread numThread = new NumThread();
        //4.将此Callable接口实现类的对象作为传递到FutureTask构造器中，创建FutureTask的对象
        FutureTask futureTask = new FutureTask(numThread);
        //5.将FutureTask的对象作为参数传递到Thread类的构造器中，创建Thread对象，并调用start()
        new Thread(futureTask).start();
        try {
            //6.获取Callable中call方法的返回值
            //get()返回值即为FutureTask构造器参数Callable实现类重写的call()的返回值。
            Object sum = futureTask.get();//得到返回值
            System.out.println("总和为：" + sum);
        } catch (InterruptedException e) {
            e.printStackTrace();
        } catch (ExecutionException e) {
            e.printStackTrace();
        }
    }
}

线程池

暂时了解，之后，会讲解

经常创建和销毁，使用量特别大的资源，比如并发情况下的线程，对性能影响很大。如何解决？提前创建好多个线程，放入线程池中，使用时直接获取，使用完放回池中。可以避免频繁的创建销毁，实现重复利用。使用线程池的好处：提高响应速度，减少了创建新线程的时间，奖励资源消耗，重复利用线程池中的线程，不需要每次都创建。便于线程管理。有一些属性：corePoolSize:核心池的大小，maxnumPoolSize:最大线程数，keeAliveTime:线程没有任务时最多保持多长时间会终止。

package 线程.Demo09;

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

class NumberThread implements Runnable{
    @Override
    public void run() {
        for(int i = 0;i <= 100;i++){
            if(i % 2 == 0){
                System.out.println(Thread.currentThread().getName() + ": " +
                        i);
            }
        }
    }
}
class NumberThread1 implements Runnable{
    @Override
    public void run() {
        for(int i = 0;i <= 100;i++){
            if(i % 2 != 0){
                System.out.println(Thread.currentThread().getName() + ": " +
                        i);
            }
        }
    }
}

public class ThreadPool {
    public static void main(String[] args) {
        //1. 提供指定线程数量的线程池
        ExecutorService service = Executors.newFixedThreadPool(10);
        ThreadPoolExecutor service1 = (ThreadPoolExecutor) service;
        //设置线程池的属性
        // System.out.println(service.getClass());
        // service1.setCorePoolSize(15);
        // service1.setKeepAliveTime();
        //2.执行指定的线程的操作。需要提供实现Runnable接口或Callable接口实现类的对象
        service.execute(new NumberThread());//适合适用于Runnable
        service.execute(new NumberThread1());//适合适用于Runnable
        // service.submit(Callable callable);//适合使用于Callable
        //3.关闭连接池
        service.shutdown();
    }

}