java多线程基础知识

已于 2023-03-11 15:21:26 修改
阅读量109 收藏 1
点赞数 2
文章标签： java 开发语言
于 2023-03-11 15:16:13 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_47910339/article/details/129463745
版权

一，线程安全问题

1，线程安全问题概述
  • 首先，什么是线程安全问题呢？

线程安全问题指的是，多个线程同时操作同一个共享资源的时候，可能会出现业务安全问题。

下面通过一个取钱的案例给同学们演示一下。案例需求如下

场景：小明和小红是一对夫妻，他们有一个共享账户，余额是10万元，
小红和小明同时来取钱，并且2人各自都在取钱100元，可能出现什么问题呢？

如下图所示，小明和小红假设都是一个线程，本类每个线程都应该执行完三步操作，才算是完成的取钱的操作。但是真实执行过程可能是下面这样子的

​ ① 小红线程只执行了判断余额是否足够（条件为true），然后CPU的执行权就被小红线程抢走了。

​ ② 小红线程也执行了判断了余额是否足够（条件也是true）, 然后CPU执行权又被小明线程抢走了。

​ ③ 小明线程由于刚才已经判断余额是否足够了，直接执行第2步，吐出了10万元钱，此时共享账户月为0。然后CPU执行权又被小红线程抢走。

​ ④ 小红线程由于刚刚也已经判断余额是否足够了，直接执行第2步，吐出了10万元钱，此时共享账户月为-100000。

你会发现，在这个取钱案例中，两个人把共享账户的钱都取了10万，但问题是只有10万块钱啊！！！

以上取钱案例中的问题，就是线程安全问题的一种体现。

2，线程安全问题代码演示

先定义一个共享的账户类

public class Account {
    private double money = 100000;

    public void getMoney() {
            if (money > 0) {
                    try {
                        //浅睡一下   1ms
                        Thread.sleep(1);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                money -= 100000;
                // （2）
                System.out.println(Thread.currentThread().getName()+"取款成功，还剩" + money);
            } else {
                System.out.println("取款失败余额不足");
            }

    }
}

在定义一个是取钱的线程类

class Test {
    public static void main(String[] args) {
        Account account = new Account();
        //通过方法引用传入参数
        // 线程1取钱
        new Thread(account::getMoney).start();
        // 线程2取钱
        new Thread(account::getMoney).start();
    }
}

控制台输出：分析，在线程1取钱，线程0也通过了判断进入然后也取钱。a就为负数了

Thread-1取款成功，还剩0.0
Thread-0取款成功，还剩-100000.0

还有其他的情况，这里再举一个都是-100的例子：

Thread-0取款成功，还剩-100000.0
Thread-1取款成功，还剩-100000.0

在共享账户类中，当两个线程都跑到标号为（2）的位置，这个时候就是账户金额经历了两次的减法，所以就还有-100000，那么两个账户再去获取的时候，就是-100000

3，并发和并行

在说并发和并行的含义之前，我们先来了解一下什么是进程、线程？

  • 正常运行的程序（软件）就是一个独立的进程
  • 线程是属于进程，一个进程中包含多个线程
  • 进程中的线程其实并发和并行同时存在（继续往下看）

我们可以打开系统的任务管理器看看（快捷键：Ctrl+Shfit+Esc），自己的电脑上目前有哪些进程。

首先，来学习一下什么是并发？ 强调的是时间段，微观上在一段时间内，几个线程交替执行

进程中的线程由CPU负责调度执行，但是CPU同时处理线程的数量是优先的，为了保证全部线程都能执行到，CPU采用轮询机制为系统的每个线程服务，由于CPU切换的速度很快，给我们的感觉这些线程在同时执行，这就是并发。（简单记：并发就是多条线程交替执行）

下面，再来学习一下什么是并行？ 强调的是时刻，在同一时间多个线程被执行

并行指的是，多个线程同时被CPU调度执行。如下图所示，多个CPU核心在执行多条线程

那么多线程到底是并发还是并行呢？

其实多个线程在我们的电脑上执行，并发和并行是同时存在的。
4，线程同步方案

线程同步的思想

让多个线程实现先后依次访问共享资源，这样就解决了安全问题。

为了解决前面的线程安全问题，我们可以使用线程同步思想。同步最常见的方案就是加锁，意思是每次只允许一个线程加锁，加锁后才能进入访问，访问完毕后自动释放锁，然后其他线程才能再加锁进来。

在这里插入图片描述

等小红线程执行完了，把余额改为0，出去了就会释放锁。这时小明线程就可以加锁进来执行，如下图所示。

采用加锁的方案，就可以解决前面两个线程都取10万块钱的问题。怎么加锁呢？Java提供了三种方案

1.同步代码块
2.同步方法
3.Lock锁
5，（ 方案一）同步代码块

同步代码块的作用 就是把访问共享数据的代码锁起来，以此保证线程安全。

锁,也叫作对象监视器 、 在java的API中有体现

原理： 每次只允许一个线程加锁后进入，执行完毕后自动解锁，其他线程才可以进来执行。

//锁对象：必须是一个唯一的对象（同一个地址）
synchronized(锁对象){
    //...访问共享数据的代码...
}

使用同步代码块，来解决前面代码里面的线程安全问题。我们只需要修改Account类中的代码即可。

    public void getMoney() {
        synchronized (this){
            if (money > 0) {
                try {
                    Thread.sleep(10);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                money -= 100000;
                System.out.println(Thread.currentThread().getName()+"取款成功，还剩" + money);
            } else {
                System.out.println("取款失败余额不足");
            }
        }
    }

锁对象该如何选择呢？

1.建议把共享资源作为锁对象, 不要将随便无关的对象当做锁对象
2.对于实例方法，建议使用this作为锁对象
3.对于静态方法，建议把类的字节码(类名.class)当做锁对象
6，（方案二）同步方法

接下来，学习同步方法解决线程安全问题。其实同步方法，就是把整个方法给锁住，一个线程调用这个方法，另一个线程调用的时候就执行不了，只有等上一个线程调用结束，下一个线程调用才能继续执行。

    public synchronized void getMoney() {
        if (money > 0) {
            try {
                Thread.sleep(10);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            money -= 100000;
            System.out.println(Thread.currentThread().getName() + "取款成功，还剩" + money);
        } else {
            System.out.println("取款失败余额不足");
        }
    }

那么同步方法有没有锁对象？锁对象是谁？

同步方法也是有锁对象，只不过这个锁对象没有显示的写出来而已。
1.对于实例方法，锁对象其实是this（也就是方法的调用者）
2.对于静态方法，锁对象时类的字节码对象（类名.class）

对比同步代码块和同步方法那个更好？

1.不存在哪个好与不好，只是一个锁住的范围大，一个范围小
2.同步方法是将方法中所有的代码锁住
3.同步代码块是将方法中的部分代码锁住
7，（方案三）Lock锁

接下来，我们再来学习一种，线程安全问题的解决办法，叫做Lock锁。

Lock锁是JDK5版本专门提供的一种锁对象，通过这个锁对象的方法来达到加锁，和释放锁的目的，使用起来更加灵活。格式如下

1.首先在成员变量位子，需要创建一个Lock接口的实现类对象（这个对象就是锁对象）
	private final Lock lk = new ReentrantLock();
2.在需要上锁的地方加入下面的代码
	 lk.lock(); // 加锁
	 //...中间是被锁住的代码...
	 lk.unlock(); // 解锁

使用Lock锁改写前面Account中取钱的方法，代码如下

    public void getMoney() {
        lock.lock();
        if (money > 0) {
            try {
                Thread.sleep(10);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            money -= 100000;
            System.out.println(Thread.currentThread().getName() + "取款成功，还剩" + money);
            
        } else {
            System.out.println("取款失败余额不足");
        }
        lock.unlock();
    }

可以试想一下，这种方法没有问题？lock方法是获得这个锁对象，unlock是释放这个锁对象，那么万一在释放锁之前程序已经崩了，那么这个对象就永远也释放不了了。存在很大的缺陷，那么有没有什么解决办法呢？看一下API有没有解决办法。

他让我们放在finally中，这样即使崩了也会释放这个锁

二，线程通信

首先，什么是线程通信呢？

  • 当多个线程共同操作共享资源时，线程间通过某种方式互相告知自己的状态，以相互协调，避免无效的资源挣抢。

线程通信的常见模式：是生产者与消费者模型

  • 生产者线程负责生成数据
  • 消费者线程负责消费生产者生成的数据
  • 注意：生产者生产完数据后应该让自己等待，通知其他消费者消费；消费者消费完数据之后应该让自己等待，同时通知生产者生成。

Object类的等待和唤醒方法：

方法名称说明
void wait()让当前线程等待并释放所占锁，直到另一个线程调用notify()方法或 notifyAll()方法
void notify()唤醒正在等待的单个线程
void notifyAll()唤醒正在等待的所有线程
注意：上述方法应该使用当前同步锁对象进行调用。

比如下面案例中，有3个厨师（生产者线程），两个顾客（消费者线程）。

在这里插入图片描述

接下来，我们先分析一下完成这个案例的思路

1.先确定在这个案例中，什么是共享数据？
	答：这里案例中桌子是共享数据，因为厨师和顾客都需要对桌子上的包子进行操作。

2.再确定有那几条线程？哪个是生产者，哪个是消费者？
	答：厨师是生产者线程，3条生产者线程； 
	   顾客是消费者线程，2条消费者线程
	   
3.什么时候将哪一个线程设置为什么状态
	生产者线程(厨师)放包子：
		 1)先判断是否有包子
		 2)没有包子时，厨师开始做包子, 做完之后把别人唤醒，然后让自己等待
		 3)有包子时，不做包子了，直接唤醒别人、然后让自己等待
		 	
	消费者线程(顾客)吃包子：
		 1)先判断是否有包子
		 2)有包子时，顾客开始吃包子, 吃完之后把别人唤醒，然后让自己等待
		 3)没有包子时，不吃包子了，直接唤醒别人、然后让自己等待

按照上面分析的思路写代码。先写桌子类，代码如下

public class Desk {
    private List<String> list = new ArrayList<>();

    // 放1个包子的方法
    // 厨师1 厨师2 厨师3
    public synchronized void put() {
        try {
            String name = Thread.currentThread().getName();
            // 判断是否有包子。
            if(list.size() == 0){
                list.add(name + "做的肉包子");
                System.out.println(name + "做了一个肉包子~~");
                Thread.sleep(2000);

                // 唤醒别人, 等待自己
                this.notifyAll();
                this.wait();
            }else {
                // 有包子了，不做了。
                // 唤醒别人, 等待自己
                this.notifyAll();
                this.wait();
            }
        } catch (Exception e) {
            e.printStackTrace();
        }
    }

    // 吃货1 吃货2
    public synchronized void get() {
        try {
            String name = Thread.currentThread().getName();
            if(list.size() == 1){
                // 有包子，吃了
                System.out.println(name  + "吃了：" + list.get(0));
                list.clear();
                Thread.sleep(1000);
                this.notifyAll();
                this.wait();
            }else {
                // 没有包子
                this.notifyAll();
                this.wait();
            }
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}

再写测试类，在测试类中，创建3个厨师线程对象，再创建2个顾客对象，并启动所有线程

public class ThreadTest {
    public static void main(String[] args) {
        //   需求：3个生产者线程，负责生产包子，每个线程每次只能生产1个包子放在桌子上
        //      2个消费者线程负责吃包子，每人每次只能从桌子上拿1个包子吃。
        Desk desk  = new Desk();

        // 创建3个生产者线程（3个厨师）
        new Thread(() -> {
            while (true) {
                desk.put();
            }
        }, "厨师1").start();

        new Thread(() -> {
            while (true) {
                desk.put();
            }
        }, "厨师2").start();

        new Thread(() -> {
            while (true) {
                desk.put();
            }
        }, "厨师3").start();

        // 创建2个消费者线程（2个吃货）
        new Thread(() -> {
            while (true) {
                desk.get();
            }
        }, "吃货1").start();

        new Thread(() -> {
            while (true) {
                desk.get();
            }
        }, "吃货2").start();
    }
}

执行上面代码，运行结果如下：你会发现多个线程相互协调执行，避免无效的资源挣抢。

厨师1做了一个肉包子~~
吃货2吃了：厨师1做的肉包子
厨师3做了一个肉包子~~
吃货2吃了：厨师3做的肉包子
厨师1做了一个肉包子~~
吃货1吃了：厨师1做的肉包子
厨师2做了一个肉包子~~
吃货2吃了：厨师2做的肉包子
厨师3做了一个肉包子~~
吃货1吃了：厨师3做的肉包子

三，线程池

1，线程池概述

接下来我们学习一下线程池技术。先认识一下什么是线程池技术？ 其实，线程池就是一个可以复用线程的技术。

要理解什么是线程复用技术，我们先得看一下不使用线程池会有什么问题，理解了这些问题之后，我们在解释线程复用同学们就好理解了。

假设：用户每次发起一个请求给后台，后台就创建一个新的线程来处理，
下次新的任务过来肯定也会创建新的线程，如果用户量非常大，
创建的线程也就越来越多。然而，创建线程是开销很大的，并且请求过多时，会严重影响系统性能。

而使用线程池，就可以解决上面的问题。如下图所示，线程池内部会有一个容器，存储几个核心线程，假设有3个核心线程，这3个核心线程可以处理3个任务。

但是任务总有被执行完的时候，假设第1个线程的任务执行完了，那么第1个线程就空闲下来了，有新的任务时，空闲下来的第1个线程可以去执行其他任务。依此内推，这3个线程可以不断的复用，也可以执行很多个任务。

所以，线程池就是一个线程复用技术，它可以很好的提高线程的利用率。

2，创建线程池

在JDK5版本中提供了代表线程池的接口ExecutorService，对ExecutorService接口中主要的的方法做一个介绍

方法名称说明
void execute(Runnable command)执行 Runnable 任务
Future submit(Callable task)执行 Callable 任务，返回未来任务对象，用于获取线程返回的结果
void shutdown()等全部任务执行完毕后，再关闭线程池！
List shutdownNow()立刻关闭线程池，停止正在执行的任务，并返回队列中未执行的任务

而这个接口下有一个实现类叫ThreadPoolExecutor类，使用ThreadPoolExecutor类就可以用来创建线程池对象。

下面是它的构造器，参数比较多，但是也挺好记忆。根据下面假设的场景来记忆，在一个小公司中

接下来，用这7个参数的构造器来创建线程池的对象。代码如下

ExecutorService pool = new ThreadPoolExecutor(
    3,	//核心线程数有3个
    5,  //最大线程数有5个。   临时线程数=最大线程数-核心线程数=5-3=2
    8,	//临时线程存活的时间8秒。 意思是临时线程8秒没有任务执行，就会被销毁掉。
    TimeUnit.SECONDS,//时间单位（秒）
    new ArrayBlockingQueue<>(4), //任务阻塞队列，没有来得及执行的任务在，任务队列中等待
    Executors.defaultThreadFactory(), //用于创建线程的工厂对象，从线程工具类中的获取
    new ThreadPoolExecutor.CallerRunsPolicy() //拒绝策略
);

关于线程池，我们需要注意下面的两个问题

  • 临时线程什么时候创建？

    新任务提交时，发现核心线程都在忙、任务队列满了、并且还可以创建临时线程，此时会创建临时线程。

  • 什么时候开始拒绝新的任务？

    核心线程和临时线程都在忙、任务队列也满了、新任务过来时才会开始拒绝任务。

下面对构造方法中的第四个参数和第七个参数做一个说明：

第四个时间的单位：这一看到TimeUnit是一个枚举类，其中包含下面的常量值

在这里插入图片描述

第七个参数：这是ThreadPoolExecutor类的内部类

策略详解
ThreadPoolExecutor.AbortPolicy丢弃任务并抛出RejectedExecutionException异常。是默认的策略
ThreadPoolExecutor.DiscardPolicy丢弃任务，但是不抛出异常 这是不推荐的做法
ThreadPoolExecutor.DiscardOldestPolicy抛弃队列中等待最久的任务 然后把当前任务加入队列中
ThreadPoolExecutor.CallerRunsPolicy由主线程负责调用任务的run()方法从而绕过线程池直接执行

在这里插入图片描述

通过下面的案例对第七个参数进行一个解释：

需求： 使用线程池的继续执行16个打印的任务，打印当前线程的信息以及任务的个数。

public class TestThreadPoolExecutor {
    public static void main(String[] args) {
        ThreadPoolExecutor pool = new ThreadPoolExecutor(
                1, 3, 100,
                TimeUnit.MILLISECONDS, new ArrayBlockingQueue<>(3),
                Executors.defaultThreadFactory(),
            // (1)  new ThreadPoolExecutor.AbortPolicy()  终止策略    默认
            // (2)  new ThreadPoolExecutor.CallerRunsPolicy()
            // (3)  new ThreadPoolExecutor.DiscardOldestPolicy()
            // (4)  new ThreadPoolExecutor.DiscardPolicy()
        );
        for (int i = 1; i <= 16; i++) {
            pool.execute(new MyRunnable(i));
        }
        pool.shutdown();
    }
}
class MyRunnable implements Runnable {
    private int i;
    public MyRunnable(int i) {
        this.i = i;
    }
    @Override
    public void run() {
        try {
            Thread.sleep(10);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println(Thread.currentThread().getName() + "  执行了任务" + i);
    }
}

控制台结果如下：

（1）：new ThreadPoolExecutor.AbortPolicy() 当达到了最大线程数，并且队列中也满了的时候，不处理直接报错.

Exception in thread "main" java.util.concurrent.RejectedExecutionException: Task com.yfs1024.demo02_testThreadPoolExecutor.MyRunnable@568db2f2 rejected from java.util.concurrent.ThreadPoolExecutor@378bf509[Running, pool size = 3, active threads = 3, queued tasks = 3, completed tasks = 0]
	at java.base/java.util.concurrent.ThreadPoolExecutor$AbortPolicy.rejectedExecution(ThreadPoolExecutor.java:2065)
	at java.base/java.util.concurrent.ThreadPoolExecutor.reject(ThreadPoolExecutor.java:833)
	at java.base/java.util.concurrent.ThreadPoolExecutor.execute(ThreadPoolExecutor.java:1365)
	at com.yfs1024.demo02_testThreadPoolExecutor.TestThreadPoolExecutor.main(TestThreadPoolExecutor.java:22)
pool-1-thread-3  执行了任务6
pool-1-thread-1  执行了任务1
pool-1-thread-2  执行了任务5
pool-1-thread-2  执行了任务4
pool-1-thread-1  执行了任务3
pool-1-thread-3  执行了任务2
// 前几个抢到了资源或者在队列中可以执行

（2） new ThreadPoolExecutor.CallerRunsPolicy()，当线程数达到了maximumPoolSize，并且队列也满了，就让主线程来执行。并且不会漏掉任何一个任务

pool-1-thread-3  执行了任务6
pool-1-thread-2  执行了任务5
pool-1-thread-1  执行了任务1
main  执行了任务7
pool-1-thread-2  执行了任务3
pool-1-thread-3  执行了任务2
pool-1-thread-2  执行了任务8
main  执行了任务11
pool-1-thread-3  执行了任务9
pool-1-thread-1  执行了任务4
main  执行了任务15
pool-1-thread-2  执行了任务10
pool-1-thread-1  执行了任务13
pool-1-thread-3  执行了任务12
pool-1-thread-2  执行了任务14
pool-1-thread-1  执行了任务16

（3）new ThreadPoolExecutor.DiscardOldestPolicy(),当线程数达到了maximumPoolSize，并且队列也满了，此时再有新的任务的时候，就把队列中，最先进入的pass掉。

pool-1-thread-2  执行了任务5
pool-1-thread-3  执行了任务6
pool-1-thread-1  执行了任务1
pool-1-thread-2  执行了任务14
pool-1-thread-3  执行了任务15
pool-1-thread-1  执行了任务16

（4）new ThreadPoolExecutor.DiscardPolicy()，当线程数达到了maximumPoolSize，并且队列也满了，如果再有新的任务，不在搭理，直等到队列有位置的时候

pool-1-thread-1  执行了任务1
pool-1-thread-2  执行了任务5
pool-1-thread-3  执行了任务6
pool-1-thread-2  执行了任务3
pool-1-thread-1  执行了任务2
pool-1-thread-3  执行了任务4
3，线程池执行Runnable任务

创建好线程池之后，接下来就可以使用线程池执行任务了。线程池执行的任务可以有两种，一种是Runnable任务；一种是Callable任务。需要任务的返回值用Callable，不需要用Runnable，上面其实已经用过了。

先准备一个线程任务类

public class MyRunnable implements Runnable{
    @Override
    public void run() {
        // 任务是干啥的？
        System.out.println(Thread.currentThread().getName() + " ==> 输出666~~");
        //为了模拟线程一直在执行，这里睡久一点
        try {
            Thread.sleep(Integer.MAX_VALUE);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }
}

下面是执行Runnable任务的代码，注意阅读注释，对照着前面的7个参数理解。

ExecutorService pool = new ThreadPoolExecutor(
    3,	//核心线程数有3个
    5,  //最大线程数有5个。   临时线程数=最大线程数-核心线程数=5-3=2
    8,	//临时线程存活的时间8秒。 意思是临时线程8秒没有任务执行，就会被销毁掉。
    TimeUnit.SECONDS,//时间单位（秒）
    new ArrayBlockingQueue<>(4), //任务阻塞队列，没有来得及执行的任务在，任务队列中等待
    Executors.defaultThreadFactory(), //用于创建线程的工厂对象
    new ThreadPoolExecutor.DiscardPolicy() //拒绝策略
);

Runnable target = new MyRunnable();
pool.execute(target); // 线程池会自动创建一个新线程，自动处理这个任务，自动执行的！
pool.execute(target); // 线程池会自动创建一个新线程，自动处理这个任务，自动执行的！
pool.execute(target); // 线程池会自动创建一个新线程，自动处理这个任务，自动执行的！

//下面4个任务在任务队列里排队
pool.execute(target);
pool.execute(target);
pool.execute(target);
pool.execute(target);

//下面2个任务，会被创建的两个临时线程处理
pool.execute(target);
pool.execute(target);
// 到了新任务的拒绝时机了！
pool.execute(target);

4，线程池执行Callable任务

使用线程池执行Callable任务。callable任务相对于Runnable任务来说，就是多了一个返回值。执行Callable任务需要用到线程池中的submit方法

方法名称说明
Future submit(Callable task)执行 Callable 任务，返回未来任务对象，用于获取线程返回的结果

先准备一个Callable线程任务

public class MyCallable implements Callable<String> {
    private int n;
    public MyCallable(int n) {
        this.n = n;
    }

    // 2、重写call方法
    @Override
    public String call() throws Exception {
        // 描述线程的任务，返回线程执行返回后的结果。
        // 需求：求1-n的和返回。
        int sum = 0;
        for (int i = 1; i <= n; i++) {
            sum += i;
        }
        return Thread.currentThread().getName() + "求出了1-" + n + "的和是：" + sum;
    }
}

再准备一个测试类，在测试类中创建线程池，并执行callable任务。

public class ThreadPoolTest2 {
    public static void main(String[] args) throws Exception {
        // 1、通过ThreadPoolExecutor创建一个线程池对象。
        ExecutorService pool = new ThreadPoolExecutor(
            3,
            5,
            8,
            TimeUnit.SECONDS, 
            new ArrayBlockingQueue<>(4),
            Executors.defaultThreadFactory(),
            new ThreadPoolExecutor.CallerRunsPolicy());

        // 2、使用线程处理Callable任务。
        Future<String> f1 = pool.submit(new MyCallable(100));
        Future<String> f2 = pool.submit(new MyCallable(200));
        Future<String> f3 = pool.submit(new MyCallable(300));
        Future<String> f4 = pool.submit(new MyCallable(400));

        // 3、执行完Callable任务后，需要通过get()方法获取返回结果。和之前我们用Callable方式一样
        System.out.println(f1.get());
        System.out.println(f2.get());
        System.out.println(f3.get());
        System.out.println(f4.get());
    }
}

5，线程池工具类 Executors <不推荐>

Java为开发者提供了一个创建线程池的工具类，叫做Executors，它提供了方法可以创建各种不能特点的线程池。如下

方法名称说明
public static ExecutorService newFixedThreadPool(int nThreads)创建固定线程数量的线程池，如果某个线程因为执行异常而结束，那么线程池会补充一个新线程替代它。
public static ExecutorService newSingleThreadExecutor()创建只有一个线程的线程池对象，如果该线程出现异常而结束，那么线程池会补充一个新线程。
public static ExecutorService newCachedThreadPool()线程数量随着任务增加而增加，如果线程任务执行完毕且空闲了60s则会被回收掉。
public static ScheduledExecutorService newScheduledThreadPool(int corePoolSize)创建一个线程池，可以实现在给定的延迟后运行任务，或者定期执行任务。
注意 ：这些方法的底层，都是通过线程池的实现类ThreadPoolExecutor创建的线程池对象。

如果有需要的场景用起来还是挺方便的，每个的测试代码如下：

有一个Runnable的实现类，中间有一个任务：

class MyRunnable1 implements Runnable{
    private int i;

    public MyRunnable1(int i) {
        this.i = i;
    }

    @Override
    public void run() {
        System.out.println(Thread.currentThread().getName() + "--->" + i);
        try {
            Thread.sleep(Integer.MAX_VALUE);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }
}

（1） 创建固定线程数量的线程池 newFixedThreadPool (int nThreads)，这些线程会轮流的把任务执行完

先看源码：

// Executors类中的newFixedThreadPool（）方法
public static ExecutorService newFixedThreadPool(int nThreads) {
    return new ThreadPoolExecutor(nThreads, nThreads,0L, TimeUnit.MILLISECONDS,
    new LinkedBlockingQueue<Runnable>());
}
// ThreadPoolExecutor中这个构造器的主要创建线程池的方法
this(corePoolSize, maximumPoolSize, keepAliveTime, unit, workQueue,
     //                                拒绝策略使用默认策略
     Executors.defaultThreadFactory(), defaultHandler);

可以看到ThreadFactory使用的是 Executors.defaultThreadFactory()
拒绝策略使用默认策略,即 大于 maximumPoolSize+队列中元素的大小就报RejectedExecutionException
但是这里显然不会，因为队列足够大，没有参数就是Integer.Max 也就是 2的23次方 -1

public class ExecutorsTest {
    public static void main(String[] args) {
        // 得到一个大小为固定为3 的线程池
        ExecutorService executorService = Executors.newFixedThreadPool(3);
        for (int i = 1; i <= 10; i++) {
            executorService.execute(new MyRunnable1(i));
        }
//         任务结束之后关闭线程池
        executorService.shutdown();
    }
}

控制台结果：十个任务交替执行，但是始终是三个线程轮流处理任务

pool-1-thread-3--->3
pool-1-thread-2--->2
pool-1-thread-3--->4
pool-1-thread-1--->1
pool-1-thread-3--->6
pool-1-thread-1--->7
pool-1-thread-3--->8
pool-1-thread-1--->9
pool-1-thread-3--->10
pool-1-thread-2--->5

（2）newSingleThreadExecutor() 创建只有一个线程的线程池对象，如果该线程出现异常而结束，那么线程池会补充一个新线程。

源码：队列长度依然是 Integer.MAX，拒绝策略是默认

public static ExecutorService newSingleThreadExecutor() {
    return new FinalizableDelegatedExecutorService
        (new ThreadPoolExecutor(1, 1,0L, TimeUnit.MILLISECONDS,
         new LinkedBlockingQueue<Runnable>()));
}

控制台输出结果：一个线程把所有的任务依次执行

pool-1-thread-1--->1
pool-1-thread-1--->2
pool-1-thread-1--->3
pool-1-thread-1--->4
pool-1-thread-1--->5
pool-1-thread-1--->6
pool-1-thread-1--->7
pool-1-thread-1--->8
pool-1-thread-1--->9
pool-1-thread-1--->10

(3 )newCachedThreadPool() 线程数量随着任务增加而增加，如果线程任务执行完毕且空闲了60s则会被回收掉。

源码：没有核心线程，全是临时线程，并且没有上限

public static ExecutorService newCachedThreadPool() {
    return new ThreadPoolExecutor(0, Integer.MAX_VALUE,60L, TimeUnit.SECONDS,
                                  new SynchronousQueue<Runnable>());
}

控制台输出结果： 创建了10个线程，来执行这十个任务

pool-1-thread-9--->9
pool-1-thread-10--->10
pool-1-thread-7--->7
pool-1-thread-2--->2
pool-1-thread-3--->3
pool-1-thread-6--->6
pool-1-thread-1--->1
pool-1-thread-8--->8
pool-1-thread-4--->4
pool-1-thread-5--->5

（4）newScheduledThreadPool(int corePoolSize) 创建一个线程池，可以实现在给定的延迟后运行任务，或者定期执行任务。

public static void main(String[] args) throws ExecutionException, InterruptedException {
    ScheduledExecutorService executorService = Executors.newScheduledThreadPool(5);
    for (int i = 1; i <= 10; i++) {
        executorService.schedule(new MyRunnable1(i), 10, TimeUnit.SECONDS);
    }
    executorService.shutdown();
}

public ScheduledFuture<?> schedule(Runnable command, long delay, TimeUnit unit);

command：执行的任务 Callable或Runnable接口实现类
delay：延时执行任务的时间
unit：延迟时间单位

执行结果：十秒之后五个线程再执行这些任务

// 暂停 10S
pool-1-thread-1--->1
pool-1-thread-4--->3
pool-1-thread-2--->4
pool-1-thread-3--->5
pool-1-thread-5--->2
pool-1-thread-4--->6
pool-1-thread-3--->8
pool-1-thread-1--->7
pool-1-thread-2--->9
pool-1-thread-5--->10
6、Executors使用可能存在的陷阱

大型并发系统环境中使用Executors如果不注意可能会出现系统风险。

在阿里巴巴的 开发手册中这样说：

OOM 全称 “Out Of Memory”，表示内存耗尽

在这里插入图片描述

四，线程的生命周期 <重要>

所谓生命周期就是线程从生到死的过程中间有哪些状态，以及这些状态之间是怎么切换的。

为了更好的理解线程的生命周期，先用人的生命周期举个例子，人从生到死有下面的几个过程。在人的生命周期过程中，各种状态之间可能会有切换，线程也是一样的。

Thread的内部中定义了一个枚举类，用来表示线程的六个状态。

​ NEW 、RUNNABLE、BLOCKED、WAITING、TIMED_WAITING、TERMINATED

NEW: 新建状态，线程还没有启动
RUNNABLE: 可以运行状态，线程调用了start()方法后处于这个状态
BLOCKED: 锁阻塞状态，没有获取到锁处于这个状态
WAITING: 无限等待状态，线程执行时被调用了wait方法处于这个状态
TIMED_WAITING: 计时等待状态，线程执行时被调用了sleep(毫秒)或者wait(毫秒)方法处于这个状态
TERMINATED: 终止状态, 线程执行完毕或者遇到异常时，处于这个状态。

这几种状态之间切换关系如下图所示

yfs1024
关注
  • 2
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
浅谈多线程生产者和消费者问题（线程的等待和唤醒）
m0_66884848的博客
04-24 966
一、概述 生产者消费者模式是一个十分经典的多线程协作的模式，弄懂生产者消费者问题能够让我们对多线程编程的理解更加深刻。所谓生产者和消费者问题，实际上就是两个线程： 生产者：生产数据以供消费者消费，即生产者线程。 消费者：消费生产者生产的数据，即消费者线程。 在这个过程中，生产者生产数据之后直接放置在共享数据区中，并不需要关心消费者的行为 消费者只需要从共享数据区中去获取数据，并不需要关心生产者的行为。 二、举个栗子 ...
Java多线程基础知识
gldzzznb的博客
04-10 3288
这是我再次学习多线程知识的一个总结，对于刚刚接触的学习者是比较友好易懂的，便于快速的理解和掌握。
Java多线程的知识点
weixin_59796310的博客
05-28 4854
Java多线程的知识点
Java基础知识总结（2021版）
热门推荐
学Java，找哪吒
01-09 25万+
前言 大家好，我是素小暖，2012年毕业，2016年通过培训转行java开发，今天2021年1月9日，转行之路跌跌绊绊，蓦然回首，已经满满的4年工作经验了？但感觉知识还是相当的匮乏，没自信，也许是努力程度还不够吧。很感谢CSDN，因为是它给了我学习的动力，之前写了一篇记录CSDN博客访问量的文章，也许大家感觉很幼稚，但真的很有用，很有效果，仿佛磕了药一样，努力学习，进步。 2020年，是我较为成功的一年，工作上，跳了槽，涨了工资；学习上，啃了几本名著（Effective Java、重构 改善既.
Java基础——多线程详解！！！！
qq_52519008的博客
10-04 4663
就是进程中的一个独立控制单元，线程在控制着进程的执行。一个进程中至少有一个进程。多线程是多任务的一种特别的形式，但多线程使用了更小的资源开销。多线程能满足程序员编写高效率的程序来达到充分利用 CPU 的目的。注意：很多多线程是模拟出来的，真正的多线程是指有多个CPU，即多核，如服务器。如果是模拟出来的多线程，即在一个CPU的情况下，在同一个时间点，CPU只执行一个代码，因为切换得很快，所以就有同时执行的错觉。程序、进程和线程的大家可以通过百度搜索得知，在这里我就不多阐述。
java多线程基础知识-电子时钟
独恋幽兰的专栏
02-14 4274
java多线程基础知识简单应用-电子时钟 参考文档《java语言程序设计》-13章多线程实现电子时钟 首先是继承Thread类实现多线程：这段程序可以初步了解线程的“同时执行”，运行可以发现每次运行的结果都是不同的。 Threads.javapackage project1_Thread; public class Threads { public static void main(
四万字爆肝总结java多线程所有知识点（史上最全总结）
初心不忘、始终方得
07-14 7438
这是笔者历时三周左右总结的所有java多线程中的知识点，只要是多线程的问题这里都可以看到，笔者使用通俗易懂的语言介绍了各个场景，以及他们实现的原理，希望对路过的你有所帮助。
Java 线程 基础知识总结
Zhangguohao666的博客
07-27 6232
文章目录线程基础生产消费者模型，synchronizedjoin方法+死锁（哲学家进餐问题）join和锁死锁有趣的Timer类Timer多线程的一个运行实例 初步认识下线程，线程怎么去实现（通过继承Thread或者实现Runnable接口） 线程基础 很不严谨的说，线程是什么？线程就是为了让很多个东东并发执行，大大的提高程序执行的效率啊 三个非常重要的概念： 程序：一组写好了的静态代码块（就我...
Java多线程（超详细！）
一只小菜鸡
05-13 12万+
1、什么是进程？什么是线程？ 进程是:一个应用程序（1个进程是一个软件）。 线程是：一个进程中的执行场景/执行单元。 注意：一个进程可以启动多个线程。 eg.对于java程序来说，当在DOS命令窗口中输入： java HelloWorld 回车之后。 会先启动JVM，而JVM就是一个进程。 JVM再启动一个主线程调用main方法。 同时再启动一个垃圾回收线程负责看护，回收垃圾。 最起码，现在的java程序中至少有两个线程并发， 一个是垃圾回收线程，一个是执行main方法的主线程。 3、进程和线程是什么关系？
JAVA多线程入门基础知识
02-22
必知必会的多线程入门基础知识
java 多线程的基础知识
最新发布
04-21
java 多线程学习笔记
Java基础之多线程
08-26
以下是我们Java基础多线程的一些知识点总结，看完以后会觉得多线程也可以这么简单，小编精心推荐，希望能对大家有所帮助
Java多线程和并发知识整理
05-18
1.1为什么需要多线程 1.2不安全示例 1.3并发问题的根源 1.4JMM 1.5线程安全的分类 1.6线程安全的方法 二、线程基础 2.1状态 2.2使用方式 2.3基础机制 2.4中断 2.5互斥同步 2.6线程合作 三、...
java多线程实验报告.doc
11-23
通过实验，我们可以了解Java多线程编程的基础知识，并掌握多线程编程的技术。 一、实验内容 实验内容包括两个部分：题目一和题目二。题目一是对Java多线程编程的基础知识的实验，包括线程的创建、线程的同步和通信...
java实现多线程卖票功能
08-25
* 本文中的示例程序是 Java多线程卖票功能的经典案例，旨在帮助读者了解Java中多线程编程的基础知识。 * 在实际应用中，需要根据具体情况选择合适的同步机制来保护共享资源。 * 在编写多线程程序时，需要注意线程...
JAVA多线程与并发学习总结分析
09-05
JAVA多线程与并发是Java编程中至关重要的概念，它们涉及到如何高效地利用多核处理器资源，提升程序的运行效率。下面将详细解释这些知识点。 首先，计算机系统使用高速缓存来提高处理器与内存间的交互速度，但在多...
Java多线程基础面试问题总结
01-20
进程线程知识点参考：线程和进程...多核CPU上的多线程才是真正的多线程，它能让你的多段逻辑同时工作，多线程，可以真正发挥出多核CPU的优势来，达到充分利用CPU的目的。 ②防止阻塞 从程序运行效率的角度来看，单核C

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

yfs1024

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值