Java高级-----多线程

JAVA高级–多线程

观看b站尚硅谷视频做的笔记

1、基本概念：程序、进程、线程

程序 (program)：为完成特定任务、用某种语言编写的一组指令的集合。即指一段静态的代码，静态对象。

进程 (process)：1)程序的一次执行过程，或是正在运行的一个程序。是一个动态的过程，有它自身的产生、存在和消亡的过程——生命周期。如：运行中的 QQ，运行中的 MP3 播放器程序是静态的，进程是动态的。2)进程作为资源分配的单位，系统在运行时会为每个进程分配不同的内存区域。

线程 (thread)：进程可细化为线程，是一个程序内部的一条执行路径。若一个进程同一时间并行执行多个线程，就是支持多线程的。·线程是调度和执行的单位。每个线程：拥有独立的运行栈、程序计数器 (pc)。多个线程：共享同一个进程中的方法区、堆。
线程切换的开销小。·一个进程中的多个线程共享相同的内存单元 / 内存地址空间—》它们从同一堆中分配对象，可以访问相同的变量和对象。这就使得线程间通信更简便、高效。但多个线程操作共享的系统资源可能就会带来安全的隐患。

1.1进程与线程

单核 CPU 和多核 CPU 的理解：单核 CPU，其实是一种假的多线程，因为在一个时间单元内，只能执行一个线程的任务。
例如：虽然有多车道，但是收费站只有一个工作人员在收费，只有收了费才能通过，那么 CPU 就好比收费人员。如果有某个人不想交钱，那么收费人员可以把他“挂起”（晾着他，等他想通了，准备好了钱，再去收费）。但是因为 CPU 时间单元特别短，因此感觉不出来。如果是多核的话，才能更好的发挥多线程的效率。（现在的服务器都是多核的）。

一个 Java 应用程序 java.exe，其实至少有三个线程：main() 主线程，gc() 垃圾回收线程，异常处理线程。当然如果发生异常，会影响主线程。

并行与并发：
并行：多个 CPU 同时执行多个任务。比如：多个人同时做不同的事。
并发：一个 CPU（采用时间片）同时执行多个任务。比如：秒杀、多
个人做同一件事。

1.2使用多线程的优点

以单核 CPU 为例，只使用单个线程先后完成多个任务（调用多个方法），
肯定比用多个线程来完成用的时间更短，为何仍需多线程呢？

多线程程序的优点：

1. 提高应用程序的响应。对图形化界面更有意义，可增强用户体验。
2. 提高计算机系统 CPU 的利用率。
3. 改善程序结构。将既长又复杂的进程分为多个线程，独立运行，利于理解和修改。

1.3何时需要多线程

程序需要同时执行两个或多个任务。
程序需要实现一些需要等待的任务时，如用户输入、文件读写操作、网络操作、搜索等。
需要一些后台运行的程序。

解决线程安全问题：3种
线程创建方式：4
线程的同步：解决线程安全问题。

2、线程的创建和使用

2.1线程的创建和启动

Java 语言的 JVM 允许程序运行多个线程，它通过 java.lang.Thread 类来
体现。

Thread 类的特性：
每个线程都是通过某个特定 Thread 对象的 run() 方法来完成操作的，经常把 run() 方法的主体称为线程体。通过该 Thread 对象的 start() 方法来启动这个线程，而非直接调用run()。

2.2Thread 类

Thread()：创建新的 Thread 对象。
Thread(String threadname)：创建线程并指定线程实例名。
Thread(Runnabletarget)：指定创建线程的目标对象，它实现了 Runnable接口中的 run 方法。
Thread(Runnable target, String name)：创建新的 Thread 对象。

2.3API 中创建线程的四种方式

JDK1.5 之前创建线程有两种方法：继承 Thread 类的方式。实现 Runnable 接口的方式。
目前两种方式都是调用的Thread类中的start（）

2.3.1方式一继承 Thread 类

2.3.1.1 步骤

1）创建一个继承于 Thread 类的子类；
2）重写 Thread 类的 run() 方法 —> 将此线程的方法声明在 run() 中；
3）创建 Thread 类的子对象；
4）通过此对象调用 start()。

2.3.1.2创建过程中的两个问题说明

问题1：启动一个线程不能直接对象调run方法的方式启动线程。而是对象调用start（）。
作用1）自动调用当前线程的run方法
作用2）启动当前线程

问题2: 若想再启动一个线程，必须重新创建一个Thread子类的对象。调用此对象的start方法。

遍历 100 以内的偶数。不可以还让已经 start() 的线程去执行。会报 IllegalThreadStateException
我们需要重现创建一个线程的对象，去 start()

例：遍历100以内的偶数

package com.zhou.java;
//1.创建继承于Thread类的子类
class Thread01 extends  Thread{
    //2.重写Thread类的run方法：将此线程的方法声明在run方法中
    @Override
    public void run() {
        for(int i=0;i<100;i++){
            if (i%2==0){
                System.out.println(Thread.currentThread().getName()+i);
            }
        }

    }
}
public  class  Test{
    public static void main(String[] args) {
        //3.创建Thread类的子对象
        Thread01 thread01 = new Thread01();//main主线程做的操作
        thread01.start();//自动调用当前线程的run方法、启动当前线程
        继承中调用start方法：调用当前线程的run方法，定义了线程的子类，调Thread类中的run方法时，将父类Thread的run方法覆盖了，即调用的就是重写后的run方法
        /*thread01.run();问题1：不能直接对象调run方法的方式启动线程
         thread01.start();问题2: 再启动一个线程，遍历 100 以内的偶数。不可以还让已经 start() 的线程去执行。会报 IllegalThreadStateException
        我们需要重现创建一个线程的对象，去 start().
        */  Thread01 thread02=   new Thread01();
       thread02.start();
      //main主线程做的操作
        for (int i = 0; i < 100; i++) {
            if(i%2==0){
   System.out.println(Thread.currentThread().getName()+i+"main()***");
            }
        }

   }

}

例：创建两个线程，一个线程遍历100以内所有的偶数，一个线程遍历100以内所有的奇数
方1：

package com.zhou.exer;

public class ThreadDemo {
    public static void main(String[] args) {

        Dameo dameo = new Dameo();
        dameo.start();

        Dameo01 dameo01 = new Dameo01();
        dameo01.start();


    }


}


class Dameo extends Thread {
    @Override
    public void run() {
        for (int i = 0; i < 100; i++) {
            if (i % 2 == 0) {
                System.out.println(Thread.currentThread().getName() + i + "     ");


            }

        }
    }


}

class Dameo01 extends Thread {
    @Override
    public void run() {
        for (int i = 0; i < 100; i++) {
            if (i % 2 != 0) {
                System.out.println(Thread.currentThread().getName() + i + " ---------    ");


            }

        }
    }


}

方2：java匿名子类
Daemo类后面不用，只用一次，可以用匿名的方式
创建Daemo类的匿名子类的方式：

package com.zhou.exer;

public class ThreadDemo {
    public static void main(String[] args) {
       new Thread(){
       
          @Override
           public void run() {
               for (int i = 0; i < 100; i++) {
                   if (i % 2 == 0) {
                       System.out.println(Thread.currentThread().getName() + i + "     ");


                   }

               }
           }
       }.start();



       new Thread(){

           @Override
           public void run() {
               for (int i = 0; i < 100; i++) {
                   if (i % 2 != 0) {
                       System.out.println(Thread.currentThread().getName() + i + " ---------    ");


                   }

               }

           }
       }.start();



    }




}


class Dameo extends Thread {
    @Override
    public void run() {
        for (int i = 0; i < 100; i++) {
            if (i % 2 == 0) {
                System.out.println(Thread.currentThread().getName() + i + "     ");


            }

        }
    }


}

class Dameo01 extends Thread {
    @Override
    public void run() {
        for (int i = 0; i < 100; i++) {
            if (i % 2 != 0) {
                System.out.println(Thread.currentThread().getName() + i + " ---------    ");


            }

        }
    }


}

2.3.2方式二实现runable接口

引入：用继承Thead方式创建三个窗口买票，总票数100张

package com.zhou.java;

public class WindowExtendsTest {
    public static void main(String[] args) {
        Window01 window01 = new Window01();
        Window01 window02 = new Window01();
        Window01 window03 = new Window01();

        window01.setName("窗口1:");
        window02.setName("窗口2:");
        window03.setName("窗口3:");

        window01.start();
        window02.start();
        window03.start();

    }



}
class  Window01 extends  Thread{
    private static int ticket =100;
    @Override
    public void run() {
        while (true){

            if (ticket>0){
                System.out.println(Thread.currentThread().getName()+"：卖票，票号为："+ticket);
                ticket--;



            }
        }
    }
}

运行结果:
窗口3:：卖票，票号为：100
窗口2:：卖票，票号为：100
窗口1:：卖票，票号为：100
窗口2:：卖票，票号为：98
窗口3:：卖票，票号为：99
窗口2:：卖票，票号为：96
窗口1:：卖票，票号为：97
窗口2:：卖票，票号为：94
窗口3:：卖票，票号为：95
窗口2:：卖票，票号为：92
窗口1:：卖票，票号为：93
窗口2:：卖票，票号为：90
窗口3:：卖票，票号为：91
窗口2:：卖票，票号为：88
窗口1:：卖票，票号为：89
窗口2:：卖票，票号为：86
窗口3:：卖票，票号为：87
窗口2:：卖票，票号为：84
窗口1:：卖票，票号为：85
窗口2:：卖票，票号为：82
窗口3:：卖票，票号为：83
窗口2:：卖票，票号为：80
窗口1:：卖票，票号为：81
窗口2:：卖票，票号为：78
窗口3:：卖票，票号为：79
窗口2:：卖票，票号为：76
窗口1:：卖票，票号为：77
窗口2:：卖票，票号为：74
窗口3:：卖票，票号为：75
窗口2:：卖票，票号为：72
窗口1:：卖票，票号为：73
窗口2:：卖票，票号为：70
窗口3:：卖票，票号为：71
窗口2:：卖票，票号为：68
窗口1:：卖票，票号为：69
窗口2:：卖票，票号为：66
窗口3:：卖票，票号为：67
窗口2:：卖票，票号为：64
窗口1:：卖票，票号为：65
窗口2:：卖票，票号为：62
窗口3:：卖票，票号为：63
窗口2:：卖票，票号为：60
窗口1:：卖票，票号为：61
窗口1:：卖票，票号为：57
窗口1:：卖票，票号为：56
窗口1:：卖票，票号为：55
窗口1:：卖票，票号为：54
窗口1:：卖票，票号为：53
窗口1:：卖票，票号为：52
窗口1:：卖票，票号为：51
窗口1:：卖票，票号为：50
窗口1:：卖票，票号为：49
窗口2:：卖票，票号为：58
窗口3:：卖票，票号为：59
窗口2:：卖票，票号为：47
窗口2:：卖票，票号为：45
窗口1:：卖票，票号为：48
窗口2:：卖票，票号为：44
窗口2:：卖票，票号为：42
窗口2:：卖票，票号为：41
窗口2:：卖票，票号为：40
窗口2:：卖票，票号为：39
窗口3:：卖票，票号为：46
窗口3:：卖票，票号为：37
窗口2:：卖票，票号为：38
窗口1:：卖票，票号为：43
窗口2:：卖票，票号为：35
窗口3:：卖票，票号为：36
窗口2:：卖票，票号为：33
窗口1:：卖票，票号为：34
窗口2:：卖票，票号为：31
窗口3:：卖票，票号为：32
窗口2:：卖票，票号为：29
窗口1:：卖票，票号为：30
窗口2:：卖票，票号为：27
窗口3:：卖票，票号为：28
窗口2:：卖票，票号为：25
窗口1:：卖票，票号为：26
窗口2:：卖票，票号为：23
窗口3:：卖票，票号为：24
窗口2:：卖票，票号为：21
窗口1:：卖票，票号为：22
窗口2:：卖票，票号为：19
窗口3:：卖票，票号为：20
窗口2:：卖票，票号为：17
窗口1:：卖票，票号为：18
窗口2:：卖票，票号为：15
窗口3:：卖票，票号为：16
窗口2:：卖票，票号为：13
窗口1:：卖票，票号为：14
窗口2:：卖票，票号为：11
窗口3:：卖票，票号为：12
窗口2:：卖票，票号为：9
窗口1:：卖票，票号为：10
窗口2:：卖票，票号为：7
窗口3:：卖票，票号为：8
窗口2:：卖票，票号为：5
窗口1:：卖票，票号为：6
窗口2:：卖票，票号为：3
窗口3:：卖票，票号为：4
窗口2:：卖票，票号为：1
窗口1:：卖票，票号为：2

问题1：每个窗口卖100张票，出现300张票。
分析：代码没有报错，不满足需求，依据面向对象的逻辑。
window类提供一个实例变量ticket，造了三个对象，即每个对象有一份100张票。
解决方法1：在实例变量加static关键字，变成共用数据只有一份
解决方法2：实现runable接口的方式

在Java多线程中，实例变量是多个线程共享资源，同步访问时可能出现问题。
类变量：也叫静态变量，是一种比较特殊的实例变量，用static关键字修饰。一个类的静态变量，所有由这类生成的对象都共用这个类变量，类装载时就分配存储空间。一个对象修改了变量，则所以对象中这个变量的值都会发生改变。

问题2：出现3个100，线程安全问题

package com.zhou.java;

//实现三个窗口，总共卖100张票
//也存在线程安全问题
public class WindowImplentRunnbleTest {

    public static void main(String[] args) {
        Window window = new Window();
        Thread thread01 = new Thread(window);
        Thread thread02 = new Thread(window);
        Thread thread03 = new Thread(window);

        thread01.setName("窗口1：");
        thread02.setName("窗口2：");
        thread03.setName("窗口3：");

        thread01.start();
        thread02.start();
        thread03.start();


    }
}

class Window implements Runnable {
    private int ticket = 100;

    @Override
    public void run() {
        while (true) {
            if (ticket > 0) {
                System.out.println(Thread.currentThread().getName() + ":卖票：票号为：" + ticket);
                ticket--;


            } else {
                break;


            }


        }


    }
}

运行结果：
窗口1：:卖票：票号为：100
窗口3：:卖票：票号为：100
窗口2：:卖票：票号为：100
窗口3：:卖票：票号为：98
窗口1：:卖票：票号为：99
窗口1：:卖票：票号为：95
窗口3：:卖票：票号为：96
窗口2：:卖票：票号为：97
窗口3：:卖票：票号为：93
窗口3：:卖票：票号为：91
窗口1：:卖票：票号为：94
窗口1：:卖票：票号为：89
窗口3：:卖票：票号为：90
窗口2：:卖票：票号为：92
窗口3：:卖票：票号为：87
窗口1：:卖票：票号为：88
窗口3：:卖票：票号为：85
窗口2：:卖票：票号为：86
窗口3：:卖票：票号为：83
窗口1：:卖票：票号为：84
窗口3：:卖票：票号为：81
窗口2：:卖票：票号为：82
窗口3：:卖票：票号为：79
窗口1：:卖票：票号为：80
窗口3：:卖票：票号为：77
窗口2：:卖票：票号为：78
窗口3：:卖票：票号为：75
窗口1：:卖票：票号为：76
窗口3：:卖票：票号为：73
窗口2：:卖票：票号为：74
窗口3：:卖票：票号为：71
窗口1：:卖票：票号为：72
窗口3：:卖票：票号为：69
窗口2：:卖票：票号为：70
窗口3：:卖票：票号为：67
窗口1：:卖票：票号为：68
窗口3：:卖票：票号为：65
窗口2：:卖票：票号为：66
窗口3：:卖票：票号为：63
窗口1：:卖票：票号为：64
窗口3：:卖票：票号为：61
窗口2：:卖票：票号为：62
窗口2：:卖票：票号为：58
窗口3：:卖票：票号为：59
窗口1：:卖票：票号为：60
窗口3：:卖票：票号为：56
窗口3：:卖票：票号为：54
窗口3：:卖票：票号为：53
窗口3：:卖票：票号为：52
窗口3：:卖票：票号为：51
窗口3：:卖票：票号为：50
窗口3：:卖票：票号为：49
窗口3：:卖票：票号为：48
窗口2：:卖票：票号为：57
窗口2：:卖票：票号为：46
窗口2：:卖票：票号为：45
窗口3：:卖票：票号为：47
窗口1：:卖票：票号为：55
窗口3：:卖票：票号为：43
窗口2：:卖票：票号为：44
窗口3：:卖票：票号为：41
窗口1：:卖票：票号为：42
窗口3：:卖票：票号为：39
窗口2：:卖票：票号为：40
窗口3：:卖票：票号为：37
窗口3：:卖票：票号为：35
窗口3：:卖票：票号为：34
窗口1：:卖票：票号为：38
窗口3：:卖票：票号为：33
窗口2：:卖票：票号为：36
窗口2：:卖票：票号为：30
窗口2：:卖票：票号为：29
窗口2：:卖票：票号为：28
窗口2：:卖票：票号为：27
窗口2：:卖票：票号为：26
窗口2：:卖票：票号为：25
窗口2：:卖票：票号为：24
窗口2：:卖票：票号为：23
窗口2：:卖票：票号为：22
窗口2：:卖票：票号为：21
窗口2：:卖票：票号为：20
窗口2：:卖票：票号为：19
窗口2：:卖票：票号为：18
窗口3：:卖票：票号为：31
窗口1：:卖票：票号为：32
窗口3：:卖票：票号为：16
窗口3：:卖票：票号为：14
窗口3：:卖票：票号为：13
窗口3：:卖票：票号为：12
窗口2：:卖票：票号为：17
窗口3：:卖票：票号为：11
窗口1：:卖票：票号为：15
窗口3：:卖票：票号为：9
窗口2：:卖票：票号为：10
窗口3：:卖票：票号为：7
窗口1：:卖票：票号为：8
窗口3：:卖票：票号为：5
窗口2：:卖票：票号为：6
窗口3：:卖票：票号为：3
窗口1：:卖票：票号为：4
窗口3：:卖票：票号为：1
窗口2：:卖票：票号为：2

2.3.2.1步骤

实现runable接口的步骤：
1.）创建一个实现了 Runnable 接口的类;
2.）实现类去实现 Runnable 中的抽象方法 :run();
3.）创建实现类的对象;
4.）将此对象作为参数传递到 Thread 类的构造器中,创建 Thread 类的对象;
5.）通过 Thread 类的对象调用 start();

package com.zhou.exer;

public class ThreadRunTest {
    public static void main(String[] args) {
        //3.创建实现类的对象
        RunThreadTest runThreadTest = new RunThreadTest();
        //4.创建Thread类对象，将此对象作为thread类的参数传入到thread类的构造器中
        Thread thread = new Thread(runThreadTest);
        //5.实现方式通过Thread类对象调用start（）:调用start的方法时，执行的是Thread类的run方法  
    @Override
    public void run() {
        if (target != null) {
            target.run();
        }
    }
    
target是Thread类定义的属性或变量，是一个Runnable类型创建Thread对象时，使用的构造器是Runnable。
此处调用的Thread类的start方法，为啥调用的是RunThreadTest中的方法。因为当前线程的 run() --> 调用了 Runnable 类型的 target 的 run() 
   // 作用 ①启动线程 ②调用run（）方法
   而继承中调用start方法：调用当前线程的run方法，定义了线程的子类，调Thread类中的run方法时，将父类Thread的run方法覆盖了，即调用的就是重写后的run方法
        thread.setName("线程1");
        thread.start();
        Thread thread1 = new Thread( runThreadTest);
        thread1.setName("线程2");
        thread1.start();




    }
}

//1.创建一个实现了runnable接口的类
class RunThreadTest implements  Runnable{
    //2.实现类去实现runnable中抽象方法：run（）
    @Override
    public void run() {
        for (int i = 0; i < 100; i++) {
            if (i%2==0){
                System.out.println(Thread.currentThread().getName()+":"+i);
  //不能这么写：System.out.println(getName()+":"+i);因为这里不是继承的是Thread,而是继承的是Object类

、

            }

        }
    }
}

2.3.3方式三实现Callable 接口

实现 Callable 接口 —> JDK 5.0 新增。

如何理解实现 Callable 接口的方式创建多线程比实现Runnable 接口创建多线程方式强大？
1）call() 可以有返回值的。（分线程返回一个结果，给另一线程使用）
2） call() 可以抛出异常，被外面操作捕获，获取异常信息。
3）Callable 支持泛型。
4）需要借助 FutureTask 类，比如获取返回结果。

Future 接口：可以对具体 Runnable、Callable 任务的执行结果进行取消、查询是否完成、获取结果等。

FutrueTask 是 Futrue 接口的唯一的实现类。
FutureTask 同时实现了 Runnable, Future 接口。它既
可以作为 Runnable 被线程执行，又可以作为 Future 得到
Callable 的返回值。

2.3.3.1步骤

1）创建一个实现 Callable 的实现类
2）实现 call 方法，将此线程需要执行的操作声明在 call() 中
3）创建 Callable 接口实现类的对象
4）将此 Callable 接口实现类的对象作为传递到 FutureTask 构
造器中，创建 FutureTask 的对象
5）将 FutureTask 的对象作为参数传递到 Thread 类的构造器
中，创建 Thread 对象，并调用 start()
6）获取 Callable 中 call 方法的返回值

package com.zhou.java;

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

public class CallableTest {
    public static void main(String[] args) {
        //3. 创建 Callable 接口实现类的对象
        CallableTest01 callableTest = new CallableTest01();

     //4.   将此 Callable 接口实现类的对象作为传递到 FutureTask 构造器中，创建 FutureTask 的对象

        FutureTask futureTask = new FutureTask(callableTest);
        //5. 将 FutureTask 的对象作为参数传递到 Thread 类的构造器，创建 Thread 对象，并调用 start()
        Thread thread = new Thread(futureTask );
        thread.start();
        // 6. 获取 Callable 中 call 方法的返回值
        // get() 返回值即为 FutureTask 构造器参数 Callable 实现类重写的 call() 的返回值

        try {
            Object sum = futureTask.get();//通过futureTask.get()获取 形参new FutureTask(callableTest);  Callable接口实现类对象中的call（）回调方法，
            // 没有显式的调用call方法，自动回调的call方法，即就是100以内的偶数的和通过get方法返回
            System.out.println("总和为 :" + sum);
        } catch (InterruptedException e) {
            e.printStackTrace();
        } catch (ExecutionException e) {
            e.printStackTrace();
        }

    }





}
    //1. 创建一个实现 Callable 的实现类

class  CallableTest01 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;//此处有一个转换，将int类型转换为Integer,Integer作为Object的子类，赋给Object类，相当于多态形式
    }
}

2.3.4方式四线程池

2.3.4.1基础

经常创建和销毁、使用量特别大的资源，比如并发情况下的线程，对性能影响很大。

提前创建好多个线程，放入线程池中，使用时直接获取，使用完放回池中。可以避免频繁创建销毁、实现重复利用。类似生活中的公共交通工具

好处：1）提高响应速度（减少了创建新线程的时间）
2）降低资源消耗（重复利用线程池中线程，不需要每次都创建）
3）便于线程管理

      corePoolSize：核心池的大小
      maximumPoolSize：最大线程数
      keepAliveTime：线程没有任务时最多保持多长时间后会终止

2.3.4.2步骤

1）提供指定线程数量的线程池
2）执行指定的线程的操作。需要提供实现 Runnable 接口或Callable 接口实现类的对象
3）关闭连接池

package com.zhou.java;

import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.ThreadPoolExecutor;
//2.提供实现Runnable或Callable接口的实现类
class RunnableTest implements  Runnable{
    @Override
    public void run() {
        for (int i = 1; i <=100 ; i++) {
            if (i%2==0){

                System.out.println(Thread.currentThread().getName()+i);
            }

        }
    }
}

class RunnableTest1 implements  Runnable{
    @Override
    public void run() {
        for (int i = 1; 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 executorService = Executors.newFixedThreadPool(10);
        ThreadPoolExecutor  executorService1= (ThreadPoolExecutor)executorService;//进行强转，实际返回的对象是executorService1
        // ExecutorService属于接口，接口中的属性少，即使属于属性，也是常量，常量无法修改，即办法就是在接口的实现类中可以修改属性
        //返回来一个对象赋值于一个接口，肯定不是接口对象，接口也没有对象，可以是接口的实现类对象，际返回的对象是executorService1
        //查看接口实现类对象：.getClass()  是Object类中的一个方法，获取对象是哪一个类创建的   子类是ThreadPoolExecutor
        System.out.println(executorService.getClass());
        //设置线程池的属性
        executorService1.setCorePoolSize(15);//类的属性可以是变量
       //2.执行指定线程的操作，需要提供实现Runnable或Callable接口的实现类
        executorService.execute(new RunnableTest());
        executorService.execute(new RunnableTest1());
       //3。关闭连接池
        executorService.shutdown();


    }
}

2.3.4.3线程池相关 API

JDK 5.0 起提供了线程池相关 API：ExecutorService 和 Executors。

ExecutorService：真正的线程池接口。常见子类 ThreadPoolExecutor。
·void execute(Runnable command) ：执行任务 / 命令，没有返回值，一般用来执行 Runnable。
·Future submit(Callable task)：执行任务，有返回值，一般用来执行Callable。
·void shutdown()：关闭连接池。

Executors：工具类、线程池的工厂类，用于创建并返回不同类型的线程池。
·Executors.newCachedThreadPool()：创建一个可根据需要创建新线程的线程池。
·Executors.newFixedThreadPool(n); 创建一个可重用固定线程数的线程池。
·Executors.newSingleThreadExecutor()：创建一个只有一个线程的线程池。
·Executors.newScheduledThreadPool(n)：创建一个线程池，它可安排在给定延迟后运行命令或者定期地执行。

2.4 继承方式和实现方式的联系与区别

比较创建线程的两种方式：
开发中:优先选择:实现 Runnable 接口的方式。
原因:

1. 实现的方式没有类的单继承性的局限性。
2. 实现的方式更适合来处理多个线程有共享数据的情况。

联系:public class Thread implements Runnable，Thread类实现了Runnable的接口。

相同点:
1）两种方式都需要重写 run(), 将线程要执行的逻辑声明在 run()中。
2）要想启动线程，都是调用Thread类中的start方法。

2.5线程的分类

Java 中的线程分为两类:一种是守护线程,一种是用户线程。
・它们在几乎每个方面都是相同的,唯一的区别是判断 JVM 何时离开。
・守护线程是用来服务用户线程的,通过在 start() 方法前调用 thread.setDaemon(true) 可以把一个用户线程变成一个守护线程。
・ Java 垃圾回收就是一个典型的守护线程。
・若 JVM 中都是守护线程,当前 JVM 将退出。
・形象理解:兔死狗烹,鸟尽弓藏。

Java程序中，main线程就是用户线程，垃圾回收线程就是守护线程。

2.6线程的有关方法

2.6.1线程常用方法

1.start()：启动当前线程，执行当前线程的 run()。
2.run()：通常需要重写 Thread 类中的此方法，将创建的线程要执行的
操作声明在此方法中。
3.currentThread()：静态方法，返回当前代码执行的线程。
4.getName()：获取当前线程的名字。
5.setName()：设置当前线程的名字。
6.yield()：释放当前 CPU 的执行权。
7.join()：在线程 a 中调用线程 b 的 join(), 此时线程 a 就进入阻塞状态，
直到线程 b 完全执行完以后，线程 a 才结束阻塞状态。
8.stop()：已过时。当执行此方法时，强制结束当前线程。
9.sleep(long millitime)：让当前线程“睡眠”指定时间的 millitime 毫秒。在指定的 millitime 毫秒时间内，当前线程是阻塞状态的。
10.isAlive()：返回 boolean，判断线程是否还活着
true:表示线程没有结束
false：表示线程已经结束
11.线程通信：wait（）、notify（）、notifyAll（）此三种方法不是定义在Thread类中，而是定义在Object类中。
12.设置线程优先级
getPriority（）。返回线程优先级
setPriority(intnewPriority) ：改变线程的优先级

package com.zhou.java;

public class ThreadMethod {
    public static void main(String[] args) {
        ThreadMethod01 threadMethod01 = new ThreadMethod01();
        threadMethod01.setName("线程1：");
        threadMethod01.start();
        Thread.currentThread().setName("主线程main：");
        for (int i = 0; i <100 ; i++) {
            if(i%2==0){
                System.out.println(Thread.currentThread().getName()+":"+i);
                
            }

        }

    }

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


            }

        }
    }
}

6.yield()：释放当前 CPU 的执行权。

package com.zhou.java;

public class ThreadMethod {
    public static void main(String[] args) {
        ThreadMethod01 threadMethod01 = new ThreadMethod01();
        threadMethod01.setName("线程1：");
        threadMethod01.start();
        Thread.currentThread().setName("===========主线程main：");
        for (int i = 0; i <100 ; i++) {
            System.out.println(Thread.currentThread().getName()+":"+i);
            if(i%10==0){
            Thread.yield();

            }

        }

    }

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


            }

        }
    }
}
运行结果：
===========主线程main：:0
===========主线程main：:1
===========主线程main：:2
===========主线程main：:3
===========主线程main：:4
===========主线程main：:5
===========主线程main：:6
===========主线程main：:7
===========主线程main：:8
===========主线程main：:9
===========主线程main：:10
===========主线程main：:11
===========主线程main：:12
===========主线程main：:13
===========主线程main：:14
===========主线程main：:15
===========主线程main：:16
===========主线程main：:17
===========主线程main：:18
===========主线程main：:19
===========主线程main：:20
线程1：:0
线程1：:2
线程1：:4
===========主线程main：:21
线程1：:6
===========主线程main：:22
线程1：:8
===========主线程main：:23
线程1：:10
===========主线程main：:24
===========主线程main：:25
===========主线程main：:26
===========主线程main：:27
===========主线程main：:28
===========主线程main：:29
===========主线程main：:30
线程1：:12
线程1：:14
线程1：:16
线程1：:18
线程1：:20
线程1：:22
线程1：:24
线程1：:26
===========主线程main：:31
线程1：:28
===========主线程main：:32
线程1：:30
===========主线程main：:33
线程1：:32
===========主线程main：:34
线程1：:34
===========主线程main：:35
线程1：:36
===========主线程main：:36
线程1：:38
===========主线程main：:37
线程1：:40
===========主线程main：:38
线程1：:42
===========主线程main：:39
===========主线程main：:40
线程1：:44
线程1：:46
线程1：:48
线程1：:50
线程1：:52
线程1：:54
线程1：:56
线程1：:58
线程1：:60
线程1：:62
线程1：:64
线程1：:66
线程1：:68
线程1：:70
线程1：:72
线程1：:74
线程1：:76
线程1：:78
线程1：:80
线程1：:82
线程1：:84
线程1：:86
线程1：:88
线程1：:90
线程1：:92
线程1：:94
线程1：:96
线程1：:98
===========主线程main：:41
===========主线程main：:42
===========主线程main：:43
===========主线程main：:44
===========主线程main：:45
===========主线程main：:46
===========主线程main：:47
===========主线程main：:48
===========主线程main：:49
===========主线程main：:50
===========主线程main：:51
===========主线程main：:52
===========主线程main：:53
===========主线程main：:54
===========主线程main：:55
===========主线程main：:56
===========主线程main：:57
===========主线程main：:58
===========主线程main：:59
===========主线程main：:60
===========主线程main：:61
===========主线程main：:62
===========主线程main：:63
===========主线程main：:64
===========主线程main：:65
===========主线程main：:66
===========主线程main：:67
===========主线程main：:68
===========主线程main：:69
===========主线程main：:70
===========主线程main：:71
===========主线程main：:72
===========主线程main：:73
===========主线程main：:74
===========主线程main：:75
===========主线程main：:76
===========主线程main：:77
===========主线程main：:78
===========主线程main：:79
===========主线程main：:80
===========主线程main：:81
===========主线程main：:82
===========主线程main：:83
===========主线程main：:84
===========主线程main：:85
===========主线程main：:86
===========主线程main：:87
===========主线程main：:88
===========主线程main：:89
===========主线程main：:90
===========主线程main：:91
===========主线程main：:92
===========主线程main：:93
===========主线程main：:94
===========主线程main：:95
===========主线程main：:96
===========主线程main：:97
===========主线程main：:98
===========主线程main：:99

7.join()：在线程 a 中调用线程 b 的 join(), 此时线程 a 就进入阻塞状态，
直到线程 b 完全执行完以后，线程 a 才结束阻塞状态。

package com.zhou.java;

public class ThreadMethod {
    public static void main(String[] args) {
        ThreadMethod01 threadMethod01 = new ThreadMethod01();
        threadMethod01.setName("线程1：");
        threadMethod01.start();
        Thread.currentThread().setName("===========主线程main：");
        for (int i = 0; i <100 ; i++) {
            System.out.println(Thread.currentThread().getName()+":"+i);
           if (i==20){
               try {
                   threadMethod01.join();
               } catch (InterruptedException e) {
                   e.printStackTrace();
               }
           }

        }

    }

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


            }

        }
    }
}


运行结果：
===========主线程main：:0
===========主线程main：:1
===========主线程main：:2
===========主线程main：:3
===========主线程main：:4
===========主线程main：:5
===========主线程main：:6
===========主线程main：:7
===========主线程main：:8
===========主线程main：:9
===========主线程main：:10
===========主线程main：:11
===========主线程main：:12
===========主线程main：:13
===========主线程main：:14
===========主线程main：:15
===========主线程main：:16
===========主线程main：:17
===========主线程main：:18
===========主线程main：:19
===========主线程main：:20
线程1：:0
线程1：:2
线程1：:4
线程1：:6
线程1：:8
线程1：:10
线程1：:12
线程1：:14
线程1：:16
线程1：:18
线程1：:20
线程1：:22
线程1：:24
线程1：:26
线程1：:28
线程1：:30
线程1：:32
线程1：:34
线程1：:36
线程1：:38
线程1：:40
线程1：:42
线程1：:44
线程1：:46
线程1：:48
线程1：:50
线程1：:52
线程1：:54
线程1：:56
线程1：:58
线程1：:60
线程1：:62
线程1：:64
线程1：:66
线程1：:68
线程1：:70
线程1：:72
线程1：:74
线程1：:76
线程1：:78
线程1：:80
线程1：:82
线程1：:84
线程1：:86
线程1：:88
线程1：:90
线程1：:92
线程1：:94
线程1：:96
线程1：:98
===========主线程main：:21
===========主线程main：:22
===========主线程main：:23
===========主线程main：:24
===========主线程main：:25
===========主线程main：:26
===========主线程main：:27
===========主线程main：:28
===========主线程main：:29
===========主线程main：:30
===========主线程main：:31
===========主线程main：:32
===========主线程main：:33
===========主线程main：:34
===========主线程main：:35
===========主线程main：:36
===========主线程main：:37
===========主线程main：:38
===========主线程main：:39
===========主线程main：:40
===========主线程main：:41
===========主线程main：:42
===========主线程main：:43
===========主线程main：:44
===========主线程main：:45
===========主线程main：:46
===========主线程main：:47
===========主线程main：:48
===========主线程main：:49
===========主线程main：:50
===========主线程main：:51
===========主线程main：:52
===========主线程main：:53
===========主线程main：:54
===========主线程main：:55
===========主线程main：:56
===========主线程main：:57
===========主线程main：:58
===========主线程main：:59
===========主线程main：:60
===========主线程main：:61
===========主线程main：:62
===========主线程main：:63
===========主线程main：:64
===========主线程main：:65
===========主线程main：:66
===========主线程main：:67
===========主线程main：:68
===========主线程main：:69
===========主线程main：:70
===========主线程main：:71
===========主线程main：:72
===========主线程main：:73
===========主线程main：:74
===========主线程main：:75
===========主线程main：:76
===========主线程main：:77
===========主线程main：:78
===========主线程main：:79
===========主线程main：:80
===========主线程main：:81
===========主线程main：:82
===========主线程main：:83
===========主线程main：:84
===========主线程main：:85
===========主线程main：:86
===========主线程main：:87
===========主线程main：:88
===========主线程main：:89
===========主线程main：:90
===========主线程main：:91
===========主线程main：:92
===========主线程main：:93
===========主线程main：:94
===========主线程main：:95
===========主线程main：:96
===========主线程main：:97
===========主线程main：:98
===========主线程main：:99

8.stop()：已过时。当执行此方法时，强制结束当前线程。
9.sleep(long millitime)：让当前线程“睡眠”指定时间的 millitime 毫秒。
在指定的 millitime 毫秒时间内，当前线程是阻塞状态的。

```java
package com.zhou.java;

public class ThreadMethod {
    public static void main(String[] args) {
        ThreadMethod01 threadMethod01 = new ThreadMethod01();
        threadMethod01.setName("线程1：");
        threadMethod01.start();
        Thread.currentThread().setName("===========主线程main：");
        for (int i = 0; i <100 ; i++) {
            System.out.println(Thread.currentThread().getName()+":"+i);
           if (i==20){
               try {
                   threadMethod01.join();
               } catch (InterruptedException e) {
                   e.printStackTrace();
               }
           }

        }
        System.out.println(threadMethod01.isAlive());
    }

}
class  ThreadMethod01 extends Thread{
    @Override
    public void run() {
        for (int i = 0; i <100 ; i++) {
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            if(i%2==0){
                System.out.println(Thread.currentThread().getName()+":"+i);


            }

        }
    }
}

10.isAlive()：返回 boolean，判断线程是否还活着
true:表示线程没有结束
false：表示线程已经结束

```java
package com.zhou.java;

public class ThreadMethod {
    public static void main(String[] args) {
        ThreadMethod01 threadMethod01 = new ThreadMethod01();
        threadMethod01.setName("线程1：");
        threadMethod01.start();
        Thread.currentThread().setName("===========主线程main：");
        for (int i = 0; i <100 ; i++) {
            System.out.println(Thread.currentThread().getName()+":"+i);
           if (i==20){
               try {
                   threadMethod01.join();
               } catch (InterruptedException e) {
                   e.printStackTrace();
               }
           }

        }
        System.out.println(threadMethod01.isAlive());
    }

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


            }

        }
    }
}
运行结果：
===========主线程main：:0
===========主线程main：:1
===========主线程main：:2
===========主线程main：:3
===========主线程main：:4
===========主线程main：:5
===========主线程main：:6
===========主线程main：:7
===========主线程main：:8
===========主线程main：:9
===========主线程main：:10
===========主线程main：:11
===========主线程main：:12
===========主线程main：:13
===========主线程main：:14
===========主线程main：:15
===========主线程main：:16
===========主线程main：:17
===========主线程main：:18
===========主线程main：:19
===========主线程main：:20
线程1：:0
线程1：:2
线程1：:4
线程1：:6
线程1：:8
线程1：:10
线程1：:12
线程1：:14
线程1：:16
线程1：:18
线程1：:20
线程1：:22
线程1：:24
线程1：:26
线程1：:28
线程1：:30
线程1：:32
线程1：:34
线程1：:36
线程1：:38
线程1：:40
线程1：:42
线程1：:44
线程1：:46
线程1：:48
线程1：:50
线程1：:52
线程1：:54
线程1：:56
线程1：:58
线程1：:60
线程1：:62
线程1：:64
线程1：:66
线程1：:68
线程1：:70
线程1：:72
线程1：:74
线程1：:76
线程1：:78
线程1：:80
线程1：:82
线程1：:84
线程1：:86
线程1：:88
线程1：:90
线程1：:92
线程1：:94
线程1：:96
线程1：:98
===========主线程main：:21
===========主线程main：:22
===========主线程main：:23
===========主线程main：:24
===========主线程main：:25
===========主线程main：:26
===========主线程main：:27
===========主线程main：:28
===========主线程main：:29
===========主线程main：:30
===========主线程main：:31
===========主线程main：:32
===========主线程main：:33
===========主线程main：:34
===========主线程main：:35
===========主线程main：:36
===========主线程main：:37
===========主线程main：:38
===========主线程main：:39
===========主线程main：:40
===========主线程main：:41
===========主线程main：:42
===========主线程main：:43
===========主线程main：:44
===========主线程main：:45
===========主线程main：:46
===========主线程main：:47
===========主线程main：:48
===========主线程main：:49
===========主线程main：:50
===========主线程main：:51
===========主线程main：:52
===========主线程main：:53
===========主线程main：:54
===========主线程main：:55
===========主线程main：:56
===========主线程main：:57
===========主线程main：:58
===========主线程main：:59
===========主线程main：:60
===========主线程main：:61
===========主线程main：:62
===========主线程main：:63
===========主线程main：:64
===========主线程main：:65
===========主线程main：:66
===========主线程main：:67
===========主线程main：:68
===========主线程main：:69
===========主线程main：:70
===========主线程main：:71
===========主线程main：:72
===========主线程main：:73
===========主线程main：:74
===========主线程main：:75
===========主线程main：:76
===========主线程main：:77
===========主线程main：:78
===========主线程main：:79
===========主线程main：:80
===========主线程main：:81
===========主线程main：:82
===========主线程main：:83
===========主线程main：:84
===========主线程main：:85
===========主线程main：:86
===========主线程main：:87
===========主线程main：:88
===========主线程main：:89
===========主线程main：:90
===========主线程main：:91
===========主线程main：:92
===========主线程main：:93
===========主线程main：:94
===========主线程main：:95
===========主线程main：:96
===========主线程main：:97
===========主线程main：:98
===========主线程main：:99
false

11.线程通信：wait（）、notify（）、notifyAll（）
12.设置线程优先级
getPriority（）。返回线程优先级
setPriority(intnewPriority) ：改变线程的优先级

2.6.1线程的优先级方法

Threadl类中线程的优先级等级：

• MAX_PRIORITY：10
• MIN _PRIORITY：1
• NORM_PRIORITY：5 —> 默认优先级
  涉及的方法：
• getPriority() ：返回线程优先值。
• setPriority(intnewPriority) ：改变线程的优先级。
  说明 : 高优先级的线程要抢占低优先级线程 cpu 的执行权。但是只是从概率上讲，高优先级的线程高概率的情况下被执行。并不意味着只有当高优先级的线程执行完以后，低优先级的线程才会被执行。

package com.zhou.java;

public class ThreadMethod {
    public static void main(String[] args) {
        ThreadMethod01 threadMethod01 = new ThreadMethod01();
        threadMethod01.setName("子线程1：");
        //设置优先级
        threadMethod01.setPriority(Thread.MAX_PRIORITY);
        threadMethod01.start();
        Thread.currentThread().setName("===========主线程main：");
        Thread.currentThread().setPriority(Thread.MIN_PRIORITY);
        for (int i = 0; i <100 ; i++) {
            System.out.println(Thread.currentThread().getName()+":"+i);
          /* if (i==20){
               try {
                   threadMethod01.join();
               } catch (InterruptedException e) {
                   e.printStackTrace();
               }
           }*/

        }
        System.out.println(threadMethod01.isAlive());
    }

}
class  ThreadMethod01 extends Thread{
    @Override
    public void run() {
        for (int i = 0; i <100 ; i++) {
           /* try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }*/
           
                System.out.println(Thread.currentThread().getName()+":"+i+"优先级："+Thread.currentThread().getPriority());


          

        }
    }
}

运行结果：
子线程1：:0优先级：10
子线程1：:2优先级：10
子线程1：:4优先级：10
子线程1：:6优先级：10
子线程1：:8优先级：10
子线程1：:10优先级：10
子线程1：:12优先级：10
子线程1：:14优先级：10
子线程1：:16优先级：10
子线程1：:18优先级：10
子线程1：:20优先级：10
子线程1：:22优先级：10
子线程1：:24优先级：10
子线程1：:26优先级：10
子线程1：:28优先级：10
子线程1：:30优先级：10
子线程1：:32优先级：10
子线程1：:34优先级：10
子线程1：:36优先级：10
子线程1：:38优先级：10
子线程1：:40优先级：10
子线程1：:42优先级：10
子线程1：:44优先级：10
子线程1：:46优先级：10
子线程1：:48优先级：10
子线程1：:50优先级：10
子线程1：:52优先级：10
子线程1：:54优先级：10
子线程1：:56优先级：10
子线程1：:58优先级：10
子线程1：:60优先级：10
子线程1：:62优先级：10
子线程1：:64优先级：10
子线程1：:66优先级：10
子线程1：:68优先级：10
子线程1：:70优先级：10
子线程1：:72优先级：10
子线程1：:74优先级：10
子线程1：:76优先级：10
子线程1：:78优先级：10
子线程1：:80优先级：10
子线程1：:82优先级：10
子线程1：:84优先级：10
子线程1：:86优先级：10
子线程1：:88优先级：10
子线程1：:90优先级：10
子线程1：:92优先级：10
子线程1：:94优先级：10
子线程1：:96优先级：10
子线程1：:98优先级：10
===========主线程main：:0
===========主线程main：:1
===========主线程main：:2
===========主线程main：:3
===========主线程main：:4
===========主线程main：:5
===========主线程main：:6
===========主线程main：:7
===========主线程main：:8
===========主线程main：:9
===========主线程main：:10
===========主线程main：:11
===========主线程main：:12
===========主线程main：:13
===========主线程main：:14
===========主线程main：:15
===========主线程main：:16
===========主线程main：:17
===========主线程main：:18
===========主线程main：:19
===========主线程main：:20
===========主线程main：:21
===========主线程main：:22
===========主线程main：:23
===========主线程main：:24
===========主线程main：:25
===========主线程main：:26
===========主线程main：:27
===========主线程main：:28
===========主线程main：:29
===========主线程main：:30
===========主线程main：:31
===========主线程main：:32
===========主线程main：:33
===========主线程main：:34
===========主线程main：:35
===========主线程main：:36
===========主线程main：:37
===========主线程main：:38
===========主线程main：:39
===========主线程main：:40
===========主线程main：:41
===========主线程main：:42
===========主线程main：:43
===========主线程main：:44
===========主线程main：:45
===========主线程main：:46
===========主线程main：:47
===========主线程main：:48
===========主线程main：:49
===========主线程main：:50
===========主线程main：:51
===========主线程main：:52
===========主线程main：:53
===========主线程main：:54
===========主线程main：:55
===========主线程main：:56
===========主线程main：:57
===========主线程main：:58
===========主线程main：:59
===========主线程main：:60
===========主线程main：:61
===========主线程main：:62
===========主线程main：:63
===========主线程main：:64
===========主线程main：:65
===========主线程main：:66
===========主线程main：:67
===========主线程main：:68
===========主线程main：:69
===========主线程main：:70
===========主线程main：:71
===========主线程main：:72
===========主线程main：:73
===========主线程main：:74
===========主线程main：:75
===========主线程main：:76
===========主线程main：:77
===========主线程main：:78
===========主线程main：:79
===========主线程main：:80
===========主线程main：:81
===========主线程main：:82
===========主线程main：:83
===========主线程main：:84
===========主线程main：:85
===========主线程main：:86
===========主线程main：:87
===========主线程main：:88
===========主线程main：:89
===========主线程main：:90
===========主线程main：:91
===========主线程main：:92
===========主线程main：:93
===========主线程main：:94
===========主线程main：:95
===========主线程main：:96
===========主线程main：:97
===========主线程main：:98
===========主线程main：:99
false

2.7线程的调度

调度策略：时间片。
抢占式：高优先级的线程抢占 CPU。
Java 的调度方法：同优先级线程组成先进先出队列（先到先服务），使用时间片策略；对高优先级，使用优先调度的抢占式策略。

3、线程的生命周期

Thread类中的Thread.State 类
JDK 中用 Thread.State （称内部类）类定义了线程的几种状态:
1）新建:当一个 Thread 类或其子类的对象被声明并创建时,新生的线程对象处于新建状态。new操作
2）就绪:处于新建状态的线程被 start() 后,将进入线程队列等待 CPU 时间片,此时它已具备了运行的条件,只是没分配到 CPU 资源。
3）运行:当就绪的线程被调度并获得 CPU 资源时 , 便进入运行状态,run() 方法定义了线程的操作和功能。
4）阻塞:在某种特殊情况下,被人为挂起或执行输入输出操作时,让出CPU 并临时中止自己的执行,进入阻塞状态。
5）死亡:线程完成了它的全部工作或线程被提前强制性地中止或出现异常导致结束。

线程的生命周期

4、线程的同步

4.1引出问题

1、提出问题:多个线程执行的不确定性引起执行结果的不稳定。多个线程对账本的共享,会造成操作的不完整性,会破坏数据。

2、例题:模拟火车站售票程序,开启三个窗口售票。

4.2线程同步例子

例子：创建三个窗口卖票，总票数为 100 张。
使用实现 Runnable 接口、继承方式,代码如下：

//实现 Runnable 接口
package com.zhou.java;

//实现三个窗口，总共卖100张票
//也存在线程安全问题
public class WindowImplentRunnbleTest {

    public static void main(String[] args) {
        Window window = new Window();
        Thread thread01 = new Thread(window);
        Thread thread02 = new Thread(window);
        Thread thread03 = new Thread(window);

        thread01.setName("窗口1：");
        thread02.setName("窗口2：");
        thread03.setName("窗口3：");

        thread01.start();
        thread02.start();
        thread03.start();


    }
}

class Window implements Runnable {
    private int ticket = 100;

    @Override
    public void run() {
        while (true) {
            if (ticket > 0) {

                try {
                    Thread.sleep(100);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                System.out.println(Thread.currentThread().getName() + ":卖票：票号为：" + ticket);
                ticket--;


            } else {
                break;


            }


        }


    }
}

//继承
package com.zhou.java;

public class WindowExtendsTest {
    public static void main(String[] args) {
        Window01 window01 = new Window01();
        Window01 window02 = new Window01();
        Window01 window03 = new Window01();

        window01.setName("窗口1:");
        window02.setName("窗口2:");
        window03.setName("窗口3:");

        window01.start();
        window02.start();
        window03.start();

    }



}
class  Window01 extends  Thread{
    private static int ticket =100;
    @Override
    public void run() {
        while (true){

            if (ticket>0){

              
                System.out.println(Thread.currentThread().getName()+"：卖票，票号为："+ticket);
                  try {
                    Thread.sleep(100);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                ticket--;



            }
        }
    }
}

问题：

1. 卖票过程中出现重票错票 ,原因:出现了线程的安全问题。
2. 问题出现的原因 : 当某个线程操作车票的过程中，尚未操作完成时，其他线程参与进来，也操作车票。

4.3解决线程安全问题

1. 如何解决：当一个线程在操作 ticket 的时候，其他线程不能参与进来。直到线程 a 操作完 ticket 时，其他线程才可以操作 ticket。这种情况即使线程a 出现了阻塞，也不能被改变.
2. 在 java 中，我们通过同步机制，来解决线程的安全问题。

4.3.1解决办法1：同步代码块

synchronized( 同步监视器 ){
// 需要被同步的代码
}

说明：

1. 操作共享数据的代码，即为需要被同步的代码 —> 不能包含代码多了，也不能包含代码少了。
2. 共享数据：多个线程共同操作的变量。比如：ticket 就是共享数据。
3. 同步监视器，俗称：锁。任何一个类的对象，都可以来充当锁。要求：多个线程必须要共用同一把锁。
4. 补充：在实现 Runnable 接口创建多线程的方式中，可以考虑使用this 充当同步监视器。
5. 在继承Thread类创建线程的方式中，慎用this，考虑使用当前类充当同步监视器。
6. 使用同步代码块解决实现Runnable、继承的线程安全问题

//Runnable
package com.zhou.java;

import javax.print.attribute.standard.RequestingUserName;

public class WindowRunSynTest {

    public static void main(String[] args) {
        Window window = new Window();
        Thread thread01 = new Thread(window);
        Thread thread02 = new Thread(window);
        Thread thread03 = new Thread(window);

        thread01.setName("窗口1");
        thread02.setName("窗口2");
        thread03.setName("窗口3");

        thread01.start();
        thread02.start();
        thread03.start();

    }
}

class Window  implements Runnable{
    private  int ticket=100;
    Object obj= new Object();
   //Dog dog=new Dog();
    @Override
    public void run() {
        // Object obj= new Object();//不能放到此位置，此处是局部变量
        while (true){
                synchronized (obj) {
                    //synchronized (this) //此处表示的是window对象，当前对象

                    if (ticket > 0) {

                        try {
                            Thread.sleep(100);
                        } catch (InterruptedException e) {
                            e.printStackTrace();
                        }
                        System.out.println(Thread.currentThread().getName() + "：卖票，票号为：" + ticket);
                        ticket--;
                    } else {
                        break;


                    }
                }

        }


    }
}

class Dog{




}

//继承：

package com.zhou.java;

public class WindowExtendTest {

    public static void main(String[] args) {
        Window01 window01 = new Window01();
        Window01 window02 = new Window01();
        Window01 window03 = new Window01();

        window01.setName("窗口1：");
        window02.setName("窗口2：");
        window03.setName("窗口3：");

        window01.start();
        window02.start();
        window03.start();



    }
}


class Window01 extends Thread{
    private static int  ticket=100;
      private  static Object obj=  new Object();
    @Override
    public void run() {
        while (true){
            synchronized (obj) {
            //synchronized (this) //错误的，有三个对象
           //此处还可以写成 synchronized (Window01.class) 类也是对象，Window01只有一个，只会加载一次
                if (ticket > 0) {


                    System.out.println(Thread.currentThread().getName() + ":卖票，票号为：" + ticket);
                    ticket--;
                } else {

                    break;
                }
            }



        }
    }
}

4.3.2 解决办法2：同步方法

1、如果操作共享数据的代码完整的声明在一个方法中，我们不妨将此方法声明同步的。

2、同步的方式，解决了线程的安全问题。— 好处操作同步代时，只能有一个线程参与，其他线程等待。相当于是一个单线程的过程，效率低。— 局限性

3、使用同步方法解决实现 Runnable 接口的线程安全问题。

4、关于同步方法的总结：
1）同步方法仍然涉及到同步监视器，只是不需要我们显式的声明。
2）非静态的同步方法，同步监视器是：this；静态的同步方法，同步监视器是：当前类本身。
5、使用同步方法解决实现Runnable、继承的线程安全问题代码如下

Runnable

package com.zhou.java;

public class WindowSynMethodTest {
    public static void main(String[] args) {
        WindowTest windowTest = new WindowTest();
        Thread thread01 = new Thread(windowTest);

        Thread thread02 = new Thread(windowTest);
        Thread thread03 = new Thread(windowTest);

        thread01.setName("窗口1：");
        thread02.setName("窗口2：");
        thread03.setName("窗口3：");
        thread01.start();
        thread02.start();
        thread03.start();

    }
}
class WindowTest implements Runnable{
    private int ticket =100;
    @Override
    public void run() {
      while(true){
          show();


      }
    }
    public synchronized void  show(){//同步监视器：this， 当前对象windowTest
        if(ticket>0){
            System.out.println(Thread.currentThread().getName() +"：卖票，票号为："+ticket);
            ticket--;


        }



    }


}

继承：
package com.zhou.java;

public class WindowSynMethodExtend {

    public static void main(String[] args) {
        Window02 window01 = new Window02();
        Window02 window02 = new Window02();
        Window02 window03= new Window02();
        window01.setName("窗口1");
        window02.setName("窗口2");
        window03.setName("窗口3");

        window01.start();
        window02.start();
        window03.start();
    }
}

class  Window02 extends Thread{
    private   static int ticket =100;
    @Override
    public void run() {
        while(true){

            show();//非静态方法中可以调用静态方法
        }


    }
  private  static synchronized void show(){ //方法写成静态，同步监视器不是this，静态中也不能调this，表示当前类Window02.class
        //	private   synchronized void show() 同步监视器，此种方法是错误的，三个对象，window1，window2，wwindow3
        if(ticket>0){
            System.out.println(Thread.currentThread().getName()+"：卖票，票号为："+ticket);//静态方法中只能调用静态的，就用对象调方法
            ticket--;

        }

    }
}

4.3.3 解决办法3：Lock 锁方式

1.理解用ReentrantLock类的对象解决线程安全问题
java.util.concurrent.locks.Lock 接口是控制多个线程对共享资源进行访问的工具。锁提供了对共享资源的独占访问，每次只能有一个线程对 Lock 对象加锁，线程开始访问共享资源之前应先获得 Lock 对象。

ReentrantLock 类实现了 Lock ，它拥有与 synchronized相同的并发性和内存语义，在实现线程安全的控制中，比较常用的是 ReentrantLock，可以显式加锁、释放锁。

从 JDK 5.0 开始，Java 提供了更强大的线程同步机制——通过显式定义同步锁对象来实现同步。同步锁使用 Lock 对象充当。

lock 锁 —》JDK5.0 新增。注意：如果同步代码有异常，要将 unlock() 写入 finally 语句块。

2.Lock 锁方式步骤
1）实例化ReentrantLock
2）调用锁的方法
3）调用解锁方法

3.Lock 锁方式代码如下

package com.zhou.java;

import java.util.concurrent.locks.ReentrantLock;

public class LockTest {
    public static void main(String[] args) {
        WindowTest0 window = new WindowTest0();
        Thread thread01 = new Thread(window);
        Thread thread02 = new Thread(window);
        Thread thread03 = new Thread(window);

        thread01.setName("窗口1");
        thread02.setName("窗口2");
        thread03.setName("窗口3");


        thread01.start();
        thread02.start();
        thread03.start();


    }
}

class WindowTest0 implements Runnable {
    private int ticket = 100;
    //1.实例化ReentrantLock
    ReentrantLock lock = new ReentrantLock();

    @Override
    public void run() {
        while (true) {
          

            try {

                //2.调用lock锁定方法
                lock.lock();
            
                if (ticket > 0) {
                    try {
                        Thread.sleep(100);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }


                    System.out.println(Thread.currentThread().getName() + "：窗口卖票，票号为：" + ticket);
                    ticket--;
                } else {

                    break;
                }

            } finally {
                //3.调用解锁方法
                lock.unlock();

            }
        }

    }
}

4. 优先使用顺序：
   Lock -->·同步代码块（已经进入了方法体，分配了相应资源）–>·同步方法（在方法体之外）。

4.4线程安全的单例模式之懒汉式

使用同步机制将单例模式中的懒汉式改写为线程安全的。

4.5线程死锁

1. 死锁的理解：不同的线程分别占用对方需要的同步资源不放弃，都在等待对方放弃自己需要的同步资源，就形成了线程的死锁。
   2.死锁代码演示

 package com.zhou.java;

public class ThreeadLockTest {


    public static void main(String[] args) {


        final StringBuffer s1 = new StringBuffer();
        final StringBuffer s2 = new StringBuffer();

        new Thread() {
            @Override
            public void run() {
                synchronized (s1) {


                        s1.append("a");
                        s2.append("1");

                    try {
                        Thread.sleep(100);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                    System.out.println("hhhhhhh第1111111个线程hhhhhh");
                    synchronized (s2) {
                        System.out.println("hhhhhhh第ssssssss111111111个线程hhhhhh");
                            s1.append("b");
                            s2.append("2");

                            System.out.println(s1);
                            System.out.println(s2);
                    }
                }


            }
        }.start();


        new Thread(new Runnable() {
            @Override
            public void run() {

                synchronized (s2) {

                    System.out.println("hhhhhhh第二个线程hhhhhh");
                    s1.append("c");
                    System.out.println("ccc第二个线程hcccc");
                    s2.append("3");

                    try {
                        Thread.sleep(100);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                    synchronized (s1) {
                        s1.append("d");
                        s2.append("4");

                        System.out.println(s1);
                        System.out.println(s2);
                    }
                }

            }
        }) {


        }.start();

    }

}

3. 说明：
   》出现死锁后，不会出现异常，不会出现提示，只是所有的线程都处于阻塞状态，无法继续。》我们使用同步时，要避免出现死锁

4.6同步机制练习

练习：银行有一个账户。有两个储户分别向同一个账户存3000 元，每次存 1000，存 3 次。每次存完打印账户余额。

难点1：两个储户共用一个账户怎么实现？
难点2：存钱方法

package com.zhou.exer;

/*
分析：
1. 是否是多线程问题？是，两个储户线程；两种方式实现：继承、实现runnable方式
2. 是否有共享数据？有，账户（或账户余额）；
3. 是否有线程安全问题？有；
4. 需要考虑如何解决线程安全问题？同步机制：有三种方式。

*/
class   Account{

      private  double balance;


    public Account(double balance) {
        this.balance = balance;
    }


    public   synchronized void  deposit(double mnt) {

        if (mnt>0){




            balance+=mnt;
            System.out.println(Thread.currentThread().getName()+"存钱成功，余额为："+balance);


        }


        }


    }



class  Customer  extends   Thread{

    private  Account  account;


    public Customer(Account account) {
        this.account = account;
    }

    @Override
    public void run() {
        for (int i = 0; i <3 ; i++) {

            account.deposit(1000);

        }
    }
}


public class BankTest {


    public static void main(String[] args) {
        Account account = new Account(0);
        Customer c1 = new Customer( account);
        Customer c2 = new Customer( account);
        c1.setName("甲");
        c2.setName("乙");
        c1.start();
        c2.start();


    }
}

5、线程的通信

5.1线程的通信例子

理解:即就是方法的使用。

线程通信的例子：使用两个线程打印 1-100。线程 1，
线程 2 交替打印。

package com.zhou.java;


class  Number implements  Runnable{
    private  int number=1;

    private     Object Obj=new Object();


    @Override
    public void run() {
     while (true){

         synchronized (Obj){
               Obj.notify();

             if (number<=100){
                 System.out.println(Thread.currentThread().getName()+":"+number);
                 number++;
                 try {
                     Obj.wait();
                 } catch (InterruptedException e) {
                     e.printStackTrace();
                 }


             }

             else {


                 break;
             }
         }






     }



    }
}

public class CommunctionTest {
    public static void main(String[] args) {
        Number number = new Number();

        Thread thread01 = new Thread(number);

        Thread thread02= new Thread(number);

        thread01.setName("甲");
        thread02.setName("乙");

        thread01.start();
        thread02.start();

    }



}

结果：

5.2线程的通信的三个方法

wait()：一旦执行此方法，当前线程就进入阻塞状态，并释放同步监视器。
notify()：一旦执行此方法，就会唤醒被 wait 的一个线程。如果有多个线程被 wait，就唤醒优先级高的那个。
notifyAll()：一旦执行此方法，就会唤醒所有被 wait的线程。

说明：
1.wait()，notify()，notifyAll() 三个方法必须使用在同步代码块或同步方法中。
2.wait()，notify()，notifyAll() 三个方法的调用者必须
是同步代码块或同步方法中的同步监视器。否则，会出
现 IllegalMonitorStateException 异常。
不是静态的，就省略了this，是静态的就省略了类.
3.wait()，notify()，notifyAll() 三个方法是定义在java.lang.Object 类中。

5.3线程通信经典问题：生产者、消费者

生产者（Productor）将产品交给店员 (Clerk)，而消费者（Customer）从店员处取走产品，店员一次只能持有固定数量的产品 ( 比如：20)，如果生产者试图生产更多的产品，店员叫生产者停一下，如果店中有空位放产品了再通知生产者继续生产：如果店中没有产品了，店员会告诉消费者等一下，如果店中有产品了再通知消费者来取走产品。

这里可能出现两个问题：
1）生产者比消费者快时，消费者会漏掉数据没有取到。
2）消费者比生产者快时，消费者会取相同的数据。

分析：
1）是否是多线程的问题？是，生产者的线程，消费者的线程；
2） 是否有共享数据的问题？是，店员、产品、产品数；
3） 如何解决线程的安全问题？同步机制，有三种方法；
4）是否涉及线程的通信？是。

有显示父类只能是实现？？

package com.zhou.java;

/*生产者 (Productor) 将产品交给店员 (Clerk)，而消费者 (Customer) 从店
员处取走产品，店员一次只能持有固定数量的产品 ( 比如：20），如果生产
者试图生产更多的产品，店员会叫生产者停一下，如果店中有空位放产品了
再通知生产者继续生产；如果店中没有产品了，店员会告诉消费者等一下；
如果店中有产品了再通知消费者来取走产品。

分析：
1. 是否是多线程的问题？是，生产者的线程，消费者的线程；
2. 是否有共享数据的问题？是，店员、产品或产品数；
3. 如何解决线程的安全问题？同步机制，有三种方法；
4. 是否涉及线程的通信？是。*/

public class ProducerComuserTest {

    public static void main(String[] args) {
        Clerk clerk = new Clerk();

        Producer p1 = new Producer(clerk);
        Comuser c1= new Comuser(clerk);
        Comuser c2= new Comuser(clerk);
        p1.setName("生产者");
        c1.setName("消费者1");
        c2.setName("消费者2");

        p1.start();
        c1.start();
        c2.start();




    }
}

class Clerk{
 private int   productNumber=0;

    public synchronized void produceProduct() {

        if(productNumber<20){
            productNumber++;
            System.out.println(Thread.currentThread().getName()+"开始生产第"+productNumber+"个产品");
            notify();


        }else{
            try {
                wait();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }

        }
    }

    public  synchronized void cumuserProduct() {
        if(productNumber>0){
            productNumber--;
            System.out.println(Thread.currentThread().getName()+"开始消费第"+productNumber+"个产品");
            notify();


        }else {
            try {
                wait();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }

        }
    }
}



class Producer extends  Thread{

    Clerk clerk;

    public Producer(Clerk clerk) {
        this.clerk = clerk;


    }


    @Override
    public void run() {
        System.out.println(getName() + ": 开始生产产品 ......");
        while (true){
            clerk.produceProduct();

            try {
                Thread.sleep(10);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }


        }
    }
}
class Comuser extends  Thread{
    Clerk clerk;

    public Comuser(Clerk clerk) {
        this.clerk = clerk;
    }

    @Override
    public  void run() {
        System.out.println(getName() + ": 开始消费产品 ......");
        while (true){
            clerk.cumuserProduct();
            try {
                Thread.sleep(20);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }


        }
    }
}

6、JDK5.0 新增线程创建方式

7、多线程相关面试

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

2.如何解决线程安全问题？有几种方式。

3.sleep() 和 wait() 的异同？
相同点：一旦执行方法，都可以使得当前的线程进入阻塞状态。
不同点：
两个方法声明的位置不同：
Thread 类中声明 sleep()
Object 类中声明 wait()
调用的要求不同：
sleep() 可以在任何需要的场景下调用。
wait() 必须使用在同步代码块或同步方法中。
关于是否释放同步监视器：如果两个方法都使用在同步代码块或同步方法中，sleep() 不会释放锁，wait() 会释放锁

4.创建多线程有几种方式

8、多线程相关习题

1.画图说明线程的生命周期，以及各种状态切换使用到的方法
2.同步代码块中涉及到同步监视器和共享数据，谈谈你对同步监视器和共享数据的理解
3.sleep() 和 wait() 的异同？
4.写一个线程1安全的懒汉式
5.创建多线程有几种方式