2021-10-21 十、多线程

最新推荐文章于 2024-09-30 10:36:33 发布
最新推荐文章于 2024-09-30 10:36:33 发布
阅读量314 收藏 1
点赞数
分类专栏： Java基础 文章标签： java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_43901488/article/details/120886797
版权

多线程

1. 程序、进程、线程的基本概念

  1. 程序(program)：为完成特定任务、用某种语言编写的一组指令的集合。即指一段静态的代码，静态对象。
  2. 进程(process)：程序的一次执行过程，或是正在运行的一个程序。
    进程是一个动态的过程：有它自身的产生、存在和消亡的过程。——生命周期
    • 例如：运行中的QQ，运行中的MP3播放器。程序是静态的，进程是动态的。
    • 进程作为资源分配的单位，系统在运行时会为每个进程分配不同的内存区域。
  3. 线程(thread)，进程可进一步细化为线程，是一个程序内部的一条执行路径。
    1. 若一个进程同一时间并行执行多个线程，就是支持多线程的
    2. 线程是调度和执行的单位，每个线程拥有独立的运行栈和程序计数器(pc)，线程切换的开销小
    3. 一个进程中的多个线程共享相同的内存单元/内存地址空间=>它们从同一堆中分配对象，可以访问相同的变量和对象。这就使得线程间通信更简便、高效。但多个线程操作共享的系统资源可能就会带来安全的隐患。

1.1 进程与线程

在这里插入图片描述

单核CPU和多核CPU的理解（了解即可）
单核CPU，其实是一种假的多线程，因为在一个时间单元内，也只能执行一个线程的任务。例如：虽然有多车道，但是收费站只有一个工作人员在收费，只有收了费才能通过，那么CPU就好比收费人员。如果有某个人不想交钱，那么收费人员可以把他“挂起”（晾着他，等他想通了，准备好了钱，再去收费）。但是因为CPU时间单元特别短，因此感觉不出来。
多核CPU即多个CPU组成，这些CPU集成在一个芯片里，可以通过内部总线来交互数据，共享数据，这些CPU中分配出一个独立的核执行操作系统，每个核都有自己的寄存器，alu运算单元等（这些都是封装在cpu内部的），但是一级二级缓存是共享的，这些CPU通过总线来交互数据，并且工作是并行的，资源分配是由操作系统来完成的，操作系统来决定程序cpu的控制权分配，所以一个多核cpu的工作效率大多体现在操作系统的分配上，因为一个CPU基本上可以执行很多个程序，通过PCB进程控制块的方式存储当前代码段，然后来回跳转，所以当你的CPU核过多时，操作系统在分配时可能会导致部分CPU闲置。
例如：
一个Java应用程序java.exe，其实至少有三个线程：main()主线程，gc()垃圾回收线程，异常处理线程。当然如果发生异常，会影响主线程。

并行与并发的理解
并行：指在同一时刻，有多条指令在多个处理器上同时执行。所以无论从微观还是从宏观来看，二者都是一起执行的。
在这里插入图片描述
并发：指在同一时刻只能有一条指令执行，但多个进程指令被快速的轮换执行，使得在宏观上具有多个进程同时执行的效果，但在微观上并不是同时执行的，只是把时间分成若干段，使多个进程快速交替的执行。
并行比较好理解，并发这里再多一嘴。简单的说，并发就是指在一段时间内执行多个任务，这个一段时间可以是一秒，也可以很长，这段时间里面处理的任务数量就可以当成是并发量。
在这里插入图片描述

1.2 使用多线程

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

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

何时需要多线程：

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

2.线程的创建和使用

2.1 线程的创建和启动

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

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

2.2 Thread类构造器的使用

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

2.3 创建多线程的方式一：继承Thread类（before JDK1.5）

操作步骤：

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

示例：遍历100以内的所有的偶数

class MyThread extends Thread {
    /**
     * 重写Thread类的run()
     */
    @Override
    public void run() {
        for (int i = 1; i < 100; i++) {
            if (i % 2 == 0) {
                System.out.println(i);
                try {
                    sleep(1);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        }
    }
}
public class ThreadTest {
    public static void main(String[] args) {
        //创建Thread类的子对象
        MyThread t1 = new MyThread();

        //通过此对象调用start():①启动当前线程 ②调用当前线程的run()
        t1.start();
        // 我们不能通过直接调用run()的方式启动线程。
		//t1.run();
		// 已经start的线程不能再start一次，会报错，如果有需要可以重新new出一个MyThread实例
		//t1.start();
        //如下操作仍在main线程中执行的
        for(int i = 1;i < 100;i++){
            if(i % 2 == 0){
                System.out.println(i + "***main()***");
                try {
                    Thread.sleep(1);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        }
    }
}

注意：因为t1线程启动和调用需要时间，所以可能main线程中的遍历会先执行完，如果想更加明显地看出效果，可以在两个方法中加上休眠
子线程的创建和启动过程：

  1. new出子线程实例对象
  2. 调用start()方法启动线程
  3. 线程调用run()方法，执行方法中的代码

在这里插入图片描述

练习1：创建两个分线程，其中一个遍历100以内的偶数，另一个遍历100以内的奇数

// 遍历偶数
class MyThread extends Thread{
    @Override
    public void run() {
        for(int i = 0;i < 100;i++){
            if(i % 2 == 0){
            	// Thread.currentThread().getName() 获取当前线程并打印当前线程的名字
                System.out.println(Thread.currentThread().getName() + ":" + i);
            }
        }
    }
}
// 遍历奇数
class MyThread2 extends Thread{
    @Override
    public void run() {
        for(int i = 0;i < 100;i++){
            if(i % 2 != 0){
                System.out.println(Thread.currentThread().getName() + ":" + i);
            }
        }
    }
}
public class ThreadDemo {
    public static void main(String[] args) {
        MyThread m1 = new MyThread();
        m1.start();

        MyThread2 m2 = new MyThread2();
        m2.start();
    }
}

练习1的第二种写法

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

        //创建Thread类的匿名子类的方式
        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();
    }
}

2.3.1 Thread类的相关方法

方法名用途
start()启动当前线程，执行当前线程的run()
run()通常需要重写Thread类中的此方法，将创建的线程要执行的操作声明在此方法中
currentThread()静态方法，返回当前代码执行的线程
getName()获取当前线程的名字
setName()设置当前线程的名字
yield()释放当前CPU的执行权
join()在线程a中调用线程b的join(),此时线程a就进入阻塞状态，直到线程b完全执行完以后，线程a才结束阻塞状态。
stop()已过时。当执行此方法时，强制结束当前线程。
sleep(long millitime)让当前线程“睡眠”指定时间的millitime毫秒)。在指定的millitime毫秒时间内，当前线程是阻塞状态的。
isAlive()返回boolean，判断线程是否还活着
/**
 * 测试Thread类的常用方法
 */
class HelloThread extends Thread{
    @Override
    public void run() {
        for(int i = 0;i < 100; i++){

            try {
            	// 让当前线程休眠10毫秒
                sleep(10);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }

            if(i % 2 == 0){
                System.out.println(Thread.currentThread().getName() + ":" + i);
            }
//            if(i % 20 == 0){
				//释放当前CPU的执行权，将运行状态转成就绪状态，然后参加下一次CPU执行权的争夺，所以可能还会继续执行
//                yield();
//            }
        }
    }

    public HelloThread(String name){
        super(name);
    }
}

public class ThreadModeTest {
    public static void main(String[] args) {
    	// 通过构造器的方式给线程命名
        HelloThread h1 = new HelloThread("Thread : 1");

//        h1.setName("线程一"); 用set的方式命名

        h1.start();

        //给主线程命名
        Thread.currentThread().setName("主线程");

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

            if(i == 20){
                try {
                	// 阻塞主线程，执行h1线程
                    h1.join();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        }
		// 判断h1线程是否活着
        System.out.println(h1.isAlive());
    }
}

2.3.2 线程的调度

  • 调度策略

    • 时间片
      在这里插入图片描述

    • 抢占式：高优先级的线程抢占CPU

  • Java的调度方法

    • 同优先级线程组成先进先出队列（FIFO），使用时间片策略
    • 对高优先级，使用优先调度的抢占式策略

2.3.3 线程的优先级

线程的优先级等级
MAX_PRIORITY：10
MIN _PRIORITY：1
NORM_PRIORITY：5 —>默认优先级

  • 涉及的方法
    • getPriority() ：返回线程优先值
    • setPriority(intnewPriority) ：改变线程的优先级

说明：高优先级的线程要优先抢占cpu的执行权。但是只是从概率上讲，高优先级的线程高概率的情况下被执行。并不意味着只有当高优先级的线程执行完以后，低优先级的线程才会被执行。
（所以一定不要认为高优先级的线程执行完才会执行低优先级的线程！！！）

示例

class HelloThread extends Thread {
    @Override
    public void run() {
        for (int j = 0; j < 100; j++) {

//            try {
				//如果在高优先级的情况下加入线程的睡眠，那么低优先级的主线程也会运行
//                sleep(10);
//            } catch (InterruptedException e) {
//                e.printStackTrace();
//            }

            if (j % 2 == 0) {
                System.out.println(getName() + ":" + getPriority() + ":" + j);
            }
        }
    }
    public HelloThread(String name){
        super(name);
    }
}

public class ThreadModeTest {
    public static void main(String[] args) {
        HelloThread h2 = new HelloThread("Thread : 1");
        h2.start();

        //设置分线程的优先级
        h2.setPriority(Thread.MAX_PRIORITY);

        //给主线程命名
        Thread.currentThread().setName("主线程");
        Thread.currentThread().setPriority((Thread.MIN_PRIORITY));

        for(int j = 0;j < 100; j++){
            if(j % 2 == 0){
                System.out.println(Thread.currentThread().getName() + ":" + Thread.currentThread().getPriority() + ":" + j);
            }
        System.out.println(h2.isAlive());
    }
}

练习2：经典多窗口卖票问题

/**
 * 创建三个c窗口卖票，总票数为100张
 *
 * 存在线程的安全问题，待解决。
 */
class Windows extends Thread{

    private static int ticket = 100;

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

public class WindowsTest {
    public static void main(String[] args) {
        Windows t1 = new Windows();
        Windows t2 = new Windows();
        Windows t3 = new Windows();

        t1.setName("窗口1");
        t2.setName("窗口2");
        t3.setName("窗口3");

        t1.start();
        t2.start();
        t3.start();
    }
}

2.4 创建多线程的方式二：实现Runnable接口（before JDK1.5）

操作步骤：

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

示例：


//1.创建一个实现了Runnable接口的类
class MThread 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);
            }
        }
    }
}

public class ThreadTest1 {
    public static void main(String[] args) {
        //3.创建实现类的对象
        MThread m1 = new MThread();
        //4.将此对象作为参数传递到Thread类的构造器中，创建Thread类的对象
        Thread t1 = new Thread(m1);
        //5.通过Thread类的对象调用start():①启动线程 ②调用了Runnable类型的target的run()
        t1.start();

        //再启动一个线程，遍历100以内的偶数
        Thread t2 = new Thread(m1);
        t2.setName("线程2");
        t2.start();
    }
}

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

比较创建线程的两种方式。

  1. 开发中：优先选择：实现Runnable接口的方式

原因：

  1. 实现的方式没有类的单继承性的局限性
  2. 实现的方式更适合来处理多个线程有共享数据的情况。
  1. 联系：Thread本质上是实现了Runnable接口
public class Thread implements Runnable {}
  1. 相同点：两种方式都需要重写run(),将线程要执行的逻辑声明在run()中。

2.6 补充：线程的分类

Java中的线程分为两类：一种是守护线程，一种是用户线程。

  1. 它们在几乎每个方面都是相同的，唯一的区别是判断JVM何时离开。
  2. 守护线程是用来服务用户线程的，通过在start()方法前调用thread.setDaemon(true)可以把一个用户线程变成一个守护线程。
  3. Java垃圾回收就是一个典型的守护线程。
  4. 若JVM中都是守护线程，当前JVM将退出。（没有用户线程也就没必要继续守护了）
    形象理解：兔死狗烹，鸟尽弓藏

3. 线程的生命周期

JDK中用Thread.State类定义了线程的几种状态

  1. 新建(NEW)：当一个Thread类或其子类的对象被声明并创建时，新生的线程对象处于新建状态
  2. 就绪(RUNNABLE)：处于新建状态的线程被start()后，将进入线程队列等待CPU时间片，此时它已具备了运行的条件，只是没分配到CPU资源
  3. 运行(RUNNABLE)：当就绪的线程被调度并获得CPU资源时,便进入运行状态，run()方法定义了线程的操作和功能
  4. 阻塞(BLOCKED)：在某种特殊情况下，被人为挂起或执行输入输出操作时，让出CPU并临时中止自己的执行，进入阻塞状态
  5. 死亡(TERMINATED)：线程完成了它的全部工作或线程被提前强制性地中止或出现异常导致结束
    在这里插入图片描述
状态说明
Thread.State.NEW未启动状态，一个被创建的线程，但是还没有调用start方法
Thread.State.RUNNABLE可运行状态，状态是线程正在正常运行中, 当然可能会有某种耗时计算/IO等待的操作/CPU时间片切换等, 这个状态下发生的等待一般是其他系统资源, 而不是锁, Sleep等
Thread.State.BLOCKED阻塞状态， 这个状态下, 是在多个线程有同步操作的场景, 比如正在等待另一个线程的synchronized块的执行释放, 或者可重入的 synchronized块里别人调用wait()方法, 也就是这里是线程在等待进入临界区
Thread.State.WAITING等待状态，这个状态下是指线程拥有了某个锁之后, 调用了该线程的wait()方法。然后等待其他线程/锁拥有者调用 notify() / notifyAll() 以便该线程可以继续下一步操作。
Thread.State.TIMED_WAITING具有指定时间的等待状态，这个状态就是有限的(时间限制)的WAITING, 一般出现在调用wait(long)， join(long)等情况下, 另外一个线程sleep后, 也会进入TIMED_WAITING状态
Thread.State.TERMINATED已终止线程的线程状态或线程已完成执行，这个状态下表示该线程的run()方法已经执行完毕了, 基本上就等于死亡了(当时如果线程被持久持有, 可能不会被回收)

这里要区分 BLOCKED 和 WATING 的区别：
BLOCKED是在临界点外面等待进入,
WATING 是在临界点里面等待（wait()）别人notify()。线程调用了join()方法 join了另外的线程的时候, 也会进入WAITING状态, 等待被他join的线程执行结束

示例：Thread.State.NEW

        final Thread thread = new Thread(){
            @Override
            public void run() {
                System.out.println(Thread.currentThread().getName());
            }
        }; 
        // NEW
        System.out.println(thread.getState());

示例：Thread.State.RUNNABLE

        final Thread thread = new Thread(){
            @Override
            public void run() {
                System.out.println(Thread.currentThread().getName());
            }
        };
        thread.start();
        // RUNNABLE
        System.out.println(thread.getState());

示例：Thread.State.BLOCKED

        // 创建一个对象当锁
        final Object lock = new Object();

        Thread thread = new Thread() {
            @Override
            public void run() {
                synchronized (lock) {
                    System.out.println(Thread.currentThread().getName());
                }
            }
        };
        // 开启同步锁
        synchronized (lock) {
            try {
                // 开启thread线程
                thread.start();
                // 主线程进入睡眠
                Thread.sleep(1000);
                //　主线程没释放同步锁，所以thread阻塞了
                // BLOCKED
                System.out.println(thread.getState());
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }

示例：Thread.State.WAITING
调用以下方法会让当前线程进入等待状态
Object.wait()、Thread.join()、LockSupport.park()

        // 创建一个对象当锁
        final Object lock = new Object();

        Thread thread = new Thread() {
            @Override
            public void run() {
                try {
                    // 同步代码块
                    synchronized (lock) {
                        // 调用该方法的线程进入WAITING状态，调用wait()方法后，会释放对象的锁。
                        lock.wait();
                        System.out.println(Thread.currentThread().getName());
                    }
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        };
        // 启动线程
        thread.start();

        try {
            // 主线程睡1秒
            Thread.sleep(1000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        // 同步代码块
        synchronized (lock) {
            // lock.wait(); 所以thread线程进入了等待状态 
            System.out.println(thread.getState()); // WAITING
            // 通知所有等待在该对象上的线程。
            lock.notifyAll();
            // 因为锁被使用，所以进入阻塞状态
            System.out.println(thread.getState()); // BLOCKED
        }
        // RUNNABLE
        System.out.println(thread.getState());
    }

示例：Thread.State.TIMED_WAITING
调用以下方法会让当前线程进入指定时间的等待状态
Thread.sleep()、Object.wait()、Thread.join()、LockSupport.parkNanos()、LockSupport.parkUntil()

        Thread thread = new Thread() {
            @Override
            public void run() {
                try {
                    Thread.sleep(2000);
                    System.out.println(Thread.currentThread().getName());
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        };
        thread.start();

        try {
            Thread.sleep(1000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        // 睡了一秒之后就会输出TIMED_WAITING
        System.out.println(thread.getState());

示例：Thread.State.TERMINATED

Thread thread = new Thread() {
    @Override
    public void run() {
        System.out.println(Thread.currentThread().getName());
    }
};
thread.start();

try {
    Thread.sleep(1000);
} catch (InterruptedException e) {
    e.printStackTrace();
}
// TERMINATED 执行完毕
System.out.println(thread.getState().name());

4. 线程的同步

​ 多个线程执行的不确定性引起执行结果的不稳定
例如：​多个线程对账本的共享，会造成操作的不完整性，会破坏数据。
例如：上面的多线程卖票，会造成重复卖票。
…
同时取钱，可能会导致如下情况
在这里插入图片描述

示例：模拟火车站售票程序，开启三个窗口售票。

class Windows extends Thread{

    private static int ticket = 100;

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

public class WindowsTest {
    public static void main(String[] args) {
        Windows t1 = new Windows();
        Windows t2 = new Windows();
        Windows t3 = new Windows();

        t1.setName("窗口1");
        t2.setName("窗口2");
        t3.setName("窗口3");

        t1.start();
        t2.start();
        t3.start();
    }
}

理想状态：每个窗口卖出的车票有序、不重复
在这里插入图片描述
但是，可能因为阻塞等情况导致重复购票或者购票数量超出
在这里插入图片描述

4.1 同步代码块

4.1.1 处理实现Runnable的线程安全问题

例子：创建三个窗口卖票，总票数为100张.使用实现Runnable接口的方式

  1. 卖票过程中出现重票、错票 => 出现了线程的安全问题
  2. 问题出现的原因：当某个线程操作车票的过程中，尚未操作完成时，其他线程参与进来，操作了同一张车票
  3. 如何解决：当一个线程在操作ticket的时候，其他线程不能参与进来。直到线程a操作完ticket时，其他线程才可以操作ticket。这种情况即使线程a出现了阻塞，当前的ticket也不能被改变。

在java中，我们通过同步机制，来解决线程的安全问题。

方式一：同步代码块

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

说明：

  1. 操作共享数据的代码（需要被同步的代码） =>代码不能包含多了也不能包含少了。
  2. 共享数据：多个线程共同操作的变量。比如：ticket就是共享数据（因为ticket定义在runnable的实现类里面，所有线程用的都是同一个实现类，所以共享了ticket）
  3. 同步监视器，俗称：锁。任何一个类的对象，都可以来充当锁。
    要求：多个线程必须要共用同一把锁。
    补充：在实现Runnable接口创建多线程的方式中，我们可以考虑使用this充当同步监视器。和tictek同理，内存中用的都是同一个runnable地址

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

同步方式的优缺点：
优点：同步的方式，解决了线程的安全问题
缺点：操作同步代码时，只能有一个线程参与，其他线程等待。相当于是一个单线程的过程，效率低

示例

class Dog{
}
class Windows1 implements Runnable{

    private int ticket = 100;
//    Object obj = new Object(); 随便指定一个对象，只要是唯一的就行
//    Dog dog = new Dog();

    @Override
    public void run() {
        while(true){
       		//此时的this:唯一的windows1的对象 
            synchronized (this) {
            //方式二:synchronized (dog) {
            //方式三:synchronized (obj) {
                if (ticket > 0) {
                    try{
                    	// sleep的时候不会释放同步锁
                        Thread.sleep(100);
                    }catch (InterruptedException e){
                        e.printStackTrace();
                    }
                    System.out.println(Thread.currentThread().getName() + ":卖票，票号为: " + ticket);
                    ticket--;
                } else {
                    break;
                }
            }
        }
    }
}
public class WindowsTest1 {
    public static void main(String[] args) {
        Windows1 w = new Windows1();

        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();
    }
}

分析同步原理
在这里插入图片描述

  1. 多个线程启动之后开始抢唯一的一把锁（同步监视器）
  2. 有一个线程之后抢到之后，其他的线程就没办法进入到同步代码块中，保证了线程安全
  3. 只有当同步代码块的代码执行完之后，线程才会释放对该同步监视器的锁定
  4. 然后循环第一步…

（这里的序号和图中的①、②…无关，只是帮助理解）

4.1.2 处理继承Thread类的线程安全问题

示例：同样是卖票
这里注意，因为我们new出来的实例就是继承了Thread的子类，所以没办法使用this当作同步监视器。（每个this都指代了自己那个线程，不能保证唯一）

class Windows extends Thread{

    private static int ticket = 100;
    private static Object obj = new Object();

    @Override
    public void run() {
        while(true){
            //方法一：使用唯一的obj对象
//            synchronized (obj) {
			// 方法二：使用Windows类，因为类也是对象，并且，类只在调用的时候在方法区中加载一次，能保证唯一
            synchronized (Windows.class){   //比如，定义一个Windows.class类型的clazz变量：Class clazz = Windows.class
            //使用this是错误的，因为此时this表示的是t1,t2,t3三个对象
//            synchronized (this) {
                if (ticket > 0) {

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

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

public class WindowsTest2 {
    public static void main(String[] args) {
        Windows t1 = new Windows();
        Windows t2 = new Windows();
        Windows t3 = new Windows();

        t1.setName("窗口1");
        t2.setName("窗口2");
        t3.setName("窗口3");

        t1.start();
        t2.start();
        t3.start();
    }
}

4.2 同步方法

4.2.1 处理实现Runnable的线程安全问题

  1. 同步方法仍然涉及到同步监视器，只是不需要我们显式的声明。
  2. 非静态的同步方法，同步监视器是：this；静态的同步方法，同步监视器是：当前类本身。

示例

class Windows3 implements Runnable {

    private int ticket = 100;

    @Override
    public void run() {
        while (true) {
            show();
        }
    }

    public synchronized void show() { //同步监视器:this
    	// 这里不需要在里面加上同步代码块，因为同步方法实现了线程安全
//        synchronized (this){
            if (ticket > 0) {
                try {
                    Thread.sleep(100);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                System.out.println(Thread.currentThread().getName() + ":卖票，票号为: " + ticket);
                ticket--;
            }
//        }
    }
}

public class WindowsTest3 {
    public static void main(String[] args) {
        Windows3 w3 = new Windows3();

        Thread t1 = new Thread(w3);
        Thread t2 = new Thread(w3);
        Thread t3 = new Thread(w3);

        t1.setName("窗口1");
        t2.setName("窗口2");
        t3.setName("窗口3");

        t1.start();
        t2.start();
        t3.start();
    }
}

4.2.2 处理继承Thread类的线程安全问题

class Windows4 extends Thread {

	// 注意在静态方法中想要使用ticket需要定义成类变量
    private static int ticket = 100;

    @Override
    public void run() {
        while (true) {
            show();
        }
    }
    private static synchronized void show(){//同步监视器：Window4.class，实现Runnable接口的也可以用这个静态方法
        //private synchronized void show(){ //同步监视器：分别为自己t1,t2,t3。此种解决方式是错误的
        if (ticket > 0) {
            try {
                Thread.sleep(100);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println(Thread.currentThread().getName() + "：卖票，票号为：" + ticket);
            ticket--;
        }
    }
}


public class WindowsTest4 {
    public static void main(String[] args) {
        Windows4 t1 = new Windows4();
        Windows4 t2 = new Windows4();
        Windows4 t3 = new Windows4();


        t1.setName("窗口1");
        t2.setName("窗口2");
        t3.setName("窗口3");

        t1.start();
        t2.start();
        t3.start();

    }
}

4.3 线程安全的单例模式（懒汉式）

上面我们在介绍面向对象的时候提到了单例模式的懒汉式是非线程安全的：因为懒汉式是在调用方法的时候才创建对象，如果在创建的过程中方法阻塞的时候，其他线程也调用这个方法，就会造成线程不安全。
这里我们通过加上同步机制，将其改为线程安全

/**
 * 使用同步机制将单例模式中的懒汉式改写为线程安全的
 */
public class BankTest {
}
class Bank{

    private Bank(){}

    private static Bank instance = null;

    // 方式一：同步方法，直接在方法上加上同步监视器，效率不高（不推荐）
    public static synchronized Singleton1 getInstanceB() {
        if (instance == null) {
            instance = new Singleton1();
        }
        return instance;
    }
    
    public static Bank getInstance(){
        //方式二：在进入方法之后就立马加上同步监视器，效率稍差
//        synchronized (Bank.class) {
//            if(instance == null){
//                instance = new Bank();
//            }
//            return instance;
//        }
        //方式三：双重检查加锁，在检查了一次实例对象为null才加上锁，效率较高，推荐
        if(instance == null) {
            synchronized (Bank.class) {
                if (instance == null) {
                    instance = new Bank();
                }
            }
        }
        return instance;
    }
}

4.4 死锁的问题

死锁形成的原因：不同的线程分别占用对方需要的同步资源不放弃，都在等待对方放弃自己需要的同步资源，就形成了线程的死锁

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

示例

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

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

        new Thread(){
            @Override
            public void run() {
            	// s1是唯一的	
                synchronized (s1){
                    s1.append("a");
                    s2.append("1");
                    try {
                    	// 这里模拟阻塞，但是却占用下面线程需要的s1
                        Thread.sleep(100);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                    // 同步代码块中嵌套同步代码块
                    synchronized (s2){
                        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){
                    s1.append("c");
                    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();
    }
}
  1. 可以发现，上面那个线程在使用s1当同步监视器的时候发生了阻塞，然后下面这个线程使用s2当同步监视器，也发生了阻塞。
  2. 当上面那个线程想要调用s2当同步监视器的时候，发现s2资源已经无法调用，需要等待下面这个线程释放资源。而下面这个线程则在等待上面那个线程释放s1资源，于是造成了死锁。

示例2

class A {
	public synchronized void foo(B b) {
		System.out.println("当前线程名: " + Thread.currentThread().getName()
				+ " 进入了A实例的foo方法"); // ①
		try {
			Thread.sleep(200);
		} catch (InterruptedException ex) {
			ex.printStackTrace();
		}
		System.out.println("当前线程名: " + Thread.currentThread().getName()
				+ " 企图调用B实例的last方法"); // ③
		b.last();
	}

	public synchronized void last() {
		System.out.println("进入了A类的last方法内部");
	}
}

class B {
	public synchronized void bar(A a) {
		System.out.println("当前线程名: " + Thread.currentThread().getName()
				+ " 进入了B实例的bar方法"); // ②
		try {
			Thread.sleep(200);
		} catch (InterruptedException ex) {
			ex.printStackTrace();
		}
		System.out.println("当前线程名: " + Thread.currentThread().getName()
				+ " 企图调用A实例的last方法"); // ④
		a.last();
	}

	public synchronized void last() {
		System.out.println("进入了B类的last方法内部");
	}
}

public class DeadLock implements Runnable {
	A a = new A();
	B b = new B();

	public void init() {
		Thread.currentThread().setName("主线程");
		// 调用a对象的foo方法
		a.foo(b);
		System.out.println("进入了主线程之后");
	}

    @Override
	public void run() {
		Thread.currentThread().setName("副线程");
		// 调用b对象的bar方法
		b.bar(a);
		System.out.println("进入了副线程之后");
	}

	public static void main(String[] args) {
		DeadLock dl = new DeadLock();
		// 执行线程dl
		new Thread(dl).start();
		// 调用dl的init方法
		dl.init();
	}
}

上面这个例子我们可以发现：

  1. dl.init();调用线程的方法，设置完主线程的名字之后，调用a对象的foo方法
  2. b对象的foo方法为同步方法，这时，同步监视器为this（a实例）
  3. 输出完之后进入了睡眠，这时DeadLock重写的run方法设置线程名字，并调用b对象的bar方法
  4. b对象的bar方法为同步方法，这时，同步监视器为this（b实例）
  5. a对象睡眠完之后，想要调用b对象的last方法，但是同步监视器（b实例）已经被用了，所以进入了阻塞状态，等同步监视器的释放
  6. b对象这时睡醒了，准备调用a对象的last方法，同理…

于是造成了死锁

4.5 解决线程安全问题的方式三：Lock锁（JDK1.5新增）

java.util.concurrent.locks.Lock接口是控制多个线程对共享资源进行访问的工具。锁（Lock）提供了对共享资源的独占访问，每次只能有一个线程对Lock对象加锁，线程开始访问共享资源之前应先获得Lock对象。
ReentrantLock类实现了Lock ，它拥有与synchronized相同的并发性和内存语义，在实现线程安全的控制中，比较常用的是ReentrantLock，可以显式加锁、释放锁。
从JDK 5.0开始，Java提供了更强大的线程同步机制——通过显式定义同步锁对象来实现同步。同步锁使用Lock对象充当。

注意：如果同步代码有异常，要将unlock()写入finally语句块（因为方法中的finally语句块一定会被执行）

面试题：synchronized 与 Lock的异同？
相同：二者都可以解决线程安全问题
不同：

  1. synchronized机制在执行完相应的同步代码以后，自动的释放同步监视器；
  2. Lock需要手动的启动同步（lock()），同时结束同步也需要手动的实现（unlock()）

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

示例

import java.util.concurrent.locks.ReentrantLock;

class Windows implements Runnable{

    private int ticket = 100;
    // 1. 实例化ReentrantLock
    private ReentrantLock lock = new ReentrantLock();
    //private ReentrantLock lock = new ReentrantLock(true); 会按照线程到的先后顺序放他们进去（FIFO）

    @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. 调用解锁方法：unlock()
                lock.unlock();
            }
        }
    }
}

public class LockTest {
    public static void main(String[] args) {
        Windows w = new Windows();

        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();
    }
}

面试题：如何解决线程安全问题？有几种方式

  1. 同步代码块
  2. 同步方法
  3. 使用Lock接口

4.5.1 Condition

Condition是在jdk 1.5中才出现的，它用来替代传统的Object的wait()、notify()实现线程间的协作，相比使用Object的wait()、notify()，使用Condition的await()、signal()这种方式实现线程间协作更加安全和高效。因此通常来说比较推荐使用Condition。

Condition的优点：可以实现多路通知功能，也就是在一个Lock对象里可以创建多个Condition（即对象监视器）实例，线程对象可以注册在指定的Condition中，从而可以有选择的进行线程通知，在调度线程上更加灵活。
而synchronized就相当于整个Lock对象中只有一个单一的Condition对象，所有的线程都注册在这个对象上。线程开始notifyAll时，需要通知所有的WAITING线程，没有选择权，会有相当大的效率问题。

示例

    // 1. 实例化ReentrantLock
    private ReentrantLock lock = new ReentrantLock();
    //private ReentrantLock lock = new ReentrantLock(true); 会按照线程到的先后顺序放他们进去（FIFO）

    // 为线程1注册一个Condition
    private final Condition condition1 = lock.newCondition();
    // 为线程2注册一个Condition
    private final Condition condition2 = lock.newCondition();
    // 为线程3注册一个Condition
    private final Condition condition3 = lock.newCondition();

说明：

  1. Condition是个接口，基本的方法就是await()和signal()方法。
  2. Condition依赖于Lock接口，生成一个Condition的基本代码是lock.newCondition()
  3. 调用Condition的await()和signal()方法，都必须在lock保护之内，就是说必须在lock.lock()和lock.unlock之间才可以使用。
  4. Conditon中的await()对应Object的wait()，Condition中的signal()对应Object的notify()，Condition中的signalAll()对应Object的notifyAll()。

5. 线程的通信

线程通信的例子：使用两个线程打印1-100。线程1, 线程2交替打印
涉及到的三个方法：
wait()：一旦执行此方法，当前线程就进入阻塞状态，并释放同步监视器。
notify()：一旦执行此方法，就会唤醒被wait的一个线程。如果有多个线程被wait，就唤醒优先级高的那个。
notifyAll()：一旦执行此方法，就会唤醒所有被wait的线程。
说明：

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

代码示例：

class Number implements Runnable{

    private int number = 1;
    // 同步监视器
    public Object obj = new Object();

    @Override
    public void run() {
        while (true){
            synchronized (obj) {
				// 唤醒被wait的线程
                obj.notify();
                if(number <= 100){
                    try {
                        Thread.sleep(10);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                    System.out.println(Thread.currentThread().getName() + ":" + number);
                    number++;
                    try {
                        //使得调用wait()方法的线程进入阻塞状态
                        obj.wait();
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }else{
                    break;
                }
            }
        }
    }
}

public class CommunicationTest {
    public static void main(String[] args) {
        Number number = new Number();
        Thread t1 = new Thread(number);
        Thread t2 = new Thread(number);

        t1.setName("线程1");
        t2.setName("线程2");

        t1.start();
        t2.start();
    }
}

问：sleep() 和 wait()的异同？

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

5.1 生产者/消费者问题

在这里插入图片描述
分析：

  1. 是否是多线程的问题？是，生产者的线程，消费者的线程
  2. 是否有共享数据的问题？是，店员、产品、产品数
  3. 如何解决线程的安全问题？同步机制，有三种方法（同步代码块、同步方法、Lock锁）
  4. 是否涉及线程的通信？是

代码分析1（同步方法）

class Clerk {
	// 商品数量
    private int productCount = 0;

    //生产产品，这里用的是同步方法
    public synchronized void produceProduct() {

        if(productCount < 20){
            productCount++;
            System.out.println(Thread.currentThread().getName() + ": 开始生产第" + productCount + "个产品");
			// 唤醒消费者线程
            notify();
        }else{
            //等待
            try {
                wait();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }

    }

    //消费产品
    public synchronized void consumeProduct() {

        if(productCount > 0){
            System.out.println(Thread.currentThread().getName() + ":开始消费第" + productCount + "个产品");
            productCount--;
			
            notify();
        }else{
            //等待
            try {
                wait();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }

}
//生产者
class Producer extends Thread {
    private Clerk clerk;

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

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

        while(true){
            try {
                Thread.sleep(10);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
			// 生产商品
            clerk.produceProduct();
        }
    }
}
//消费者
class Consumer extends Thread {  
    private Clerk clerk;

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

    @Override
    public void run() {
        System.out.println(getName() + ": 开始消费产品......");

        while(true){
            try {
                Thread.sleep(20);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
			// 消费商品
            clerk.consumeProduct();
        }

    }
}

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

        Producer p1 = new Producer(clerk);
        p1.setName("生产者1");

        Consumer c1 = new Consumer(clerk);
        c1.setName("消费者1");
        Consumer c2 = new Consumer(clerk);
        c2.setName("消费者2");

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

代码分析2（Lock+Condition）

class Clerk2 {
    // 商品数量
    private int productCount = 0;

    private final ReentrantLock lock = new ReentrantLock();
    private final Condition conditionProducer = lock.newCondition();
    private final Condition conditionConsumer = lock.newCondition();

    //生产产品，这里用的是Lock
    public void produceProduct() {
        try {
            lock.lock();
            if (productCount < 20) {
                productCount++;
                System.out.println(Thread.currentThread().getName() + ": 开始生产第" + productCount + "个产品");
            } else {
                conditionProducer.await();
            }
            // 唤醒所有消费者线程
            conditionConsumer.signalAll();
        } catch (InterruptedException e) {
            e.printStackTrace();
        } finally {
            lock.unlock();
        }
    }

    //消费产品
    public void consumeProduct() {
        try {
            lock.lock();
            if (productCount > 0) {
                System.out.println(Thread.currentThread().getName() + ":开始消费第" + productCount + "个产品");
                productCount--;
            } else {
                // 阻塞
                conditionConsumer.await();
            }
            // 唤醒生产者线程
            conditionProducer.signal();
        } catch (InterruptedException e) {
            e.printStackTrace();
        } finally {
            lock.unlock();
        }
    }

}

//生产者
class Producer2 extends Thread {
    private final Clerk2 clerk;

    public Producer2(Clerk2 clerk) {
        this.clerk = clerk;
    }

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

        while (true) {
            try {
                Thread.sleep(10);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            // 生产商品
            clerk.produceProduct();
        }
    }
}

//消费者
class Consumer2 extends Thread {
    private final Clerk2 clerk;

    public Consumer2(Clerk2 clerk) {
        this.clerk = clerk;
    }

    @Override
    public void run() {
        System.out.println(getName() + ": 开始消费产品......");

        while (true) {
            try {
                Thread.sleep(30);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            // 消费商品
            clerk.consumeProduct();
        }

    }
}

public class ProductTest2 {
    public static void main(String[] args) {
        Clerk2 clerk = new Clerk2();

        Producer2 p1 = new Producer2(clerk);
        p1.setName("生产者1");

        Consumer2 c1 = new Consumer2(clerk);
        c1.setName("消费者1");
        Consumer2 c2 = new Consumer2(clerk);
        c2.setName("消费者2");

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

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

6.1 创建多线程的方式三：实现Callable接口

如何理解实现Callable接口的方式创建多线程比实现Runnable接口创建多线程方式强大？

  1. call()可以有返回值的。
  2. call()可以抛出异常，被外面的操作捕获，获取异常的信息
  3. Callable是支持泛型的
  4. 需要借助FutureTask类，比如获取返回结果

示例

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

//1.创建一个实现Callable的实现类 泛型里面是返回值类型
class NumThread implements Callable<Integer>{

    //2.实现call方法，将此线程需要执行的操作声明在call()中
    @Override
    public Integer 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 ThreadNew {
    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()的返回值。
            Integer sum = futureTask.get();
            System.out.println("总和为:" + sum);
        } catch (InterruptedException e) {
            e.printStackTrace();
        } catch (ExecutionException e) {
            e.printStackTrace();
        }
    }
}

Future接口基本介绍

  1. 可以对具体Runnable、Callable任务的执行结果进行取消、查询是否完成、获取结果等。
  2. FutrueTask是Futrue接口的唯一的实现类
  3. FutureTask同时实现了Runnable, Future接口。它既可以作为Runnable被线程执行，又可以作为Future得到Callable的返回值

6.2 创建多线程的方式四：使用线程池

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

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

使用线程池的优点：

  1. 提高响应速度（减少了创建新线程的时间）
  2. 降低资源消耗（重复利用线程池中线程，不需要每次都创建）
  3. 便于线程管理：
    属性配置：
    1. corePoolSize：核心池的大小
    2. maximumPoolSize：最大线程数
    3. keepAliveTime：线程没有任务时最多保持多长时间后会终止
      …

示例

// 线程1
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);
            }
        }
    }
}

// 线程2
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);
            }
        }
    }
}
class NumberThread2 implements Callable<Integer> {

    //2.实现call方法，将此线程需要执行的操作声明在call()中
    @Override
    public Integer call() throws Exception {
        int sum = 0;
        for (int i = 1; i <= 100; i++) {
            if (i % 2 == 0) {
                Thread.sleep(10);
                System.out.println(Thread.currentThread().getName() + ":" + i);
                sum += i;
            }
        }
        return sum;
    }
}
// 自定义线程工厂，方便创建线程的时候命名或其他操作
class MyThreadFactory implements ThreadFactory {

    private final AtomicInteger atomicInteger = new AtomicInteger(1);

    @Override
    public Thread newThread(Runnable r) {
        final Thread thread = new Thread(r, "my-thread-" + atomicInteger.getAndIncrement());
        System.out.println(thread.getName() + "has been created");
        return thread;
    }
}

public class JavaDemo30 {
    public static void main(String[] args) {
        //1. 提供指定线程数量的线程池
/*        ExecutorService service = Executors.newFixedThreadPool(10);
        ThreadPoolExecutor service1 = (ThreadPoolExecutor) service;*/
        // Runtime.getRuntime().availableProcessors()//获取逻辑核心数，如6核心12线程，那么返回的是12
        // 推荐使用下面这种方式创建线程池
        final ThreadPoolExecutor threadPoolExecutor = new ThreadPoolExecutor(6, 10, 3,
                TimeUnit.MILLISECONDS, new LinkedBlockingQueue<>(), new MyThreadFactory());
        //设置线程池的属性
//        System.out.println(service.getClass());
//        service1.setCorePoolSize(15);
//        service1.setKeepAliveTime();

        //2.执行指定的线程的操作。需要提供实现Runnable接口或Callable接口实现类的对象
//        service.execute(new NumberThread());  //适合适用于Runable
//        service.execute(new NumberThread1());  //适合适用于Runable
        threadPoolExecutor.execute(new NumberThread());
        threadPoolExecutor.execute(new NumberThread1());

//        service.submit(Callable callable);   //适合适用于Callable
        final Future<Integer> submit = threadPoolExecutor.submit(new NumberThread2());
        try {
            System.out.println("总和：" + submit.get());
        } catch (InterruptedException e) {
            e.printStackTrace();
        } catch (ExecutionException e) {
            e.printStackTrace();
        }

        //3.关闭连接池
//        service.shutdown();
        threadPoolExecutor.shutdown();

    }
}

6.2.1 线程池相关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)：创建一个线程池，它可安排在给定延迟后运行命令或者定期地执行。

上一篇总目录下一篇
九、异常Java基础总目录十一、常用类
梦开始的地方丶
关注
专栏目录
易语言大漠多线程模块制作及多线程调用实战
511遇见
05-27 1万+
首先是多线程模块的多种制作方法和调用方法，其次每种多线程模块都实现免注册到系统调用，和免杀软的查杀，更重要的是示范了多种多线程模块的调用方法。 以下是所有视频的链接: 全部教程播单：http://i.youku.com/511yjcom 1、易语言大漠多线程播单地址：http://list.youku.com/albumlist/show/id_49750716 2、易语言大漠游戏外挂一键登录播单地址：http://list.youku.com/albumlist/show/id_49486131 3..
多线程-- 线程池使用（等待所有任务执行完和关闭线程池）
weixin_44823875的博客
03-20 7882
多线程-- 线程池（1）自定义线程池（2）java自带的线程池 （1）自定义线程池 （1）为什么使用线程池 每一个线程的启动和结束都是比较消耗时间和占用资源的。使用线程池的过程中创建固定数量的线程，不用创建多余新的线程，而是循环使用那些已经存在的线程。 （2）自定义线程池设计思路 1-准备一个任务容器 2-一次性启动10个消费者线程 3-刚开始任务容器是空的，所以线程都wait在上面 4-直到一个外部线程往这个任务容器中扔了一个“任务”，就会有一个消费者线程被唤醒 5-这个消费者线程取出“任务”，并且执行这
剑指offer(0)--手写单例模式
秦怀杂货店
06-30 467
剑指Offer的第0题：如何手写一个单例模式的代码？ 文章目录1.单例模式是什么？2.为什么要用单例模式？3.单例模式有什么优缺点？4.单例模式有哪些用法？怎么写才是单例？饿汉模式（2种）：1.public修饰，直接访问的饿汉模式2.private修饰，通过方法访问的饿汉模式3.改进后的，懒加载饿汉模式懒汉模式（2种）：1.原子操作2.指令重排 1.单例模式是什么？ 单例模式，是一种比较简单的设计模式，也是属于创建型模式（提供一种创建对象的模式或者方式）。 要点： 1.涉及一个单一的类，这个类来创建自己.
易语言多线程大漠多线程脚本主副线程
511遇见
06-01 5750
在大漠多线程模板中，脚本副线程的作用主要是一个监控线程，可以监控游戏窗口是否存在，游戏是否卡屏，是否掉线，当然你可以用来进行游戏里的其他检测监控。 511遇见易语言多线程大漠多线程 大漠多线程主副线程 .版本 2 .子程序 脚本副线程, , , 监控线程 .参数 序号, 整数型 .局部变量 dm, dmsoft .局部变量 dm_ret, 整数型 .局部变量 死循环, 逻辑型 .局部变量 任务完成, 文本型 ' 要把大漠插件接口初始化为MAT线程模型 CoInitializeEx (0, ..
511遇见易语言大漠多线程自动切换账号循环登录任务模板
511遇见
04-26 8508
自动切换账号是多线程模板的一个变化应用，你有100个账号，每次开始10个线程，当第一批账号完成任务（登录，刷任务，退出）时，我们面临最困难的是如何在原有线程的基础上，自动开启下一批（第11-20）个账号，重复任务，这是这套模板的关键核心，511遇见录制了四套多线程，和一套单线程的模板来实现自动切换账号。这一套是Pc端的最后一题，之后要录制模拟器的自动切换账号模板。本套也是执行效率最高，优化系统资源占用最好的一题。 易语言大漠多线程循环登录自动切换账号 截图预览 设计目录 1.易语言大漠多线程循
精品资料（2021-2022年收藏）全国2020年资料年1月高等教育自学考试.doc
10-10
2. **位运算**：`>>>`是无符号右移运算符，`-1>>>1`的结果会将-1的二进制表示向右移动一位，由于是无符号移位，高位补0，因此结果是`2^31 - 1`，即`1073741823`，对应十进制的`231-1`。 3. **final修饰符**：`final...
2021-2022计算机二级等级考试试题及答案No.3729.docx
11-01
这篇文档包含了2021-2022年度计算机二级等级考试的部分试题及其答案，涵盖了多个IT领域的基础知识。以下是这些题目涉及的知识点详解： 1. Internet起源于美国，这是互联网发展历史的基本常识。 2. 函数mod(23,-5)...
2021-2022计算机二级等级考试试题及答案No.10685.docx
10-25
根据给定文件的信息，我们可以总结出以下...### 21. 表达式的计算 - **问题解析**： - 表达式为`10 + 'a'`，其中'a'是字符。 - **结论**：在C语言中，字符'a'会被转换为其ASCII码值（97），因此表达式的值为107。
2021-2022计算机二级等级考试试题及答案No.1690.docx
10-29
这些知识点涉及计算机网络、TCP协议特性、Word操作常识、输入设备的功能定义、Java编程基础、数据库管理技术、多线程编程、操作系统基本原理等多个领域。接下来，我们将详细阐述每一个知识点。 ### 1. 计算机网络中...
2021-2022计算机二级等级考试试题及答案No.15976.docx
10-29
### 10. Excel的功能 - **知识点**: - Excel是一款功能强大的电子表格软件，支持复杂运算和数据分析。 - **结论**: Excel不仅适用于简单的数据处理，还适用于高级的数据分析任务。 ### 11. 数据库事务的一致性 - *...
大漠多窗口例子
09-04
大漠多窗口例子
在易语言中实现灵活的大漠多线程工作
qq_31468035的博客
03-03 1654
前排提示：笔者萌新，对大漠及多线程运用都不大熟练，自学出道，莫得文化，出现错误还请理解指正。 首先介绍下目标： 剑侠情缘1网络版 一款十分有年代感的2D游戏 配置选项里有3D但是开了不知道有啥用hhhhh 目标是写一个简单的刷怪脚本 实现多线程工作，每条线程负责一个游戏 并且每条线程可以执行不同的脚本 能每个脚本都能使用不同的用户设置（有点懒没写） 应当算得上灵活吧 成品截图 软件界面使用EXUI界面库－２０１７年老版   核心思路是把每一条工作线程和其线程信息严格与超级列表框绑定 一、开始前的准备   开
2020年易语言大漠多线程脚本教程
wjcourse的博客
02-09 1616
第一集 https://www.bilibili.com/video/av36120205 第二集 https://www.bilibili.com/video/av36421403 第三集 https://www.bilibili.com/video/av36421449 第四集 https://www.bilibili.com/video/av36958008 第五集 ht...
易语言多线程大漠多线程模板UI更新
511遇见
06-01 3250
UI更新就是对窗口的组件超级列表框发送读写，采用了封装。 大漠多线程模板源码： .版本 2 .支持库 iext .子程序 UI_更新, , , 用来更新窗口的超级列表框相关线程信息 .参数 主序号, 整数型 .参数 操作, 整数型 .局部变量 列表索引, 整数型 ' 增加 .如果真 (操作 ＝ #UI_增加) 列表索引 ＝ 窗口列表.插入表项 (, , , , , ) 窗口列表.置标题 (列表索引, 0, 到文本 (线程信息 [主序号].窗口句柄)) ' 窗口句柄 窗口列表.置标题 (列表索引,
大漠多线程循环任务自动切换模板判断账号登陆成功
511遇见
06-03 3163
本判断游戏角色是否登陆成功，录制了模拟日常任务，是否出现游戏画面，退出游戏等等小的环节，因为是自动登录，自动切换账号，所以，判断游戏是否登录成功，这一环节就是必须的，我们不能根据游戏进程是否存在，以为一键启动游戏的时候，就创建了进程，但未必进入游戏画面。 判断账号登陆成功源码： .版本 2 .子程序 模拟打怪 .参数 索引, 整数型 .判断开始 (线程 [索引].运行状态 ＞ 0) .计次循环首 (10, ) 系统处理事件 () 线程 [索引].线程 [..
易编远航第七套大漠多线程多开入门高级篇
American9993的博客
04-01 1924
易编远航第七套大漠多线程多开入门高级篇 070_第一章_1.中控台组件的简单应用讲解 070_第一章_2.易大漠多线程高级之半自动玩家版中控台界面说明 070_第一章_3.易大漠多线程高级之中控台菜单应用 070_第一章_4.易大漠多线程高级之中控台刷新窗口列表 070_第一章_5.1易大漠多线程高级之中控台多窗口执行相同任务1 070_第一章_5.2易大漠多线程高级之中控台多窗口执行相同任务2 ...
易语言大漠多线程创建线程
511遇见
05-30 3499
进程（process）和线程（thread）是操作系统的基本概念 进程是具有一定独立功能的程序关于某个数据集合上的一次运行活动,进程是系统进行资源分配和调度的一个独立单位. 线程是进程的一个实体,是CPU调度和分派的基本单位,它是比进程更小的能独立运行的基本单位.线程自己基本上不拥有系统资源,只拥有一点在运行中必不可少的资源(如程序计数器,一组寄存器和栈),但是它可与同属一个进程的其他的线程共享进程所拥有的全部资源. 一个线程可以创建和撤销另一个线程;同一个进程中的多个线程之间可以并发执行 第一课易语言大
工厂模式的介绍及实现
户伟伟的博客
09-25 145
工厂模式（Factory Pattern）是一种创建型设计模式，提供了一种创建对象的接口，而无需显式指定对象的具体类。在这种模式中，我们通过定义一个工厂类，专门负责生产各种类型的对象，这样我们可以避免直接在代码中实例化具体类，使代码更具扩展性、灵活性和维护性。解耦：客户端代码与具体的类解耦，避免了对象创建逻辑的重复。简化对象创建：通过工厂统一管理对象的创建逻辑，使代码更清晰易懂。扩展性强：新增类时，只需在工厂中增加创建逻辑，而不必修改现有的业务代码。
Spring Cloud全解析：服务调用之OpenFeign集成OkHttp
最新发布
Lxn2zh的博客
09-30 366
HTTP连接需要进行TCP三次握手，是一个比较耗时的操作，一般我们不直接使用HttpURLConnection，而是使用HttpClient/okHttp等支持连接池的客户端工具，以Feign集成OkHttp为例。OpenFeign本质是HTTP来进行服务调用的，也就是需要集成一个Http客户端。默认是HttpURLConnection方式，也就是jdk中提供的最原始的那个。要开启OkHttp ,还需要在YML 中添加开启配置项，默认是关闭的。使用的是Client接口来进行请求的。
Objective-C详解：Cocoa多线程与GCD高效实践
在iOS开发中，多线程技术是一项至关重要的技能，尤其是当应用需要高效利用设备的多核处理器能力时。本文将详细介绍Cocoa框架下的多线程开发，重点讲解Objective-C语言在iOS中的几种多线程解决方案，并着重推荐使用...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值