【多线程】Java如何实现多线程？如何保证线程安全？如何自定义线程池？

在这里插入图片描述

个人简介：Java领域新星创作者；阿里云技术博主、星级博主、专家博主；正在Java学习的路上摸爬滚打，记录学习的过程~
个人主页：.29.的博客
学习社区：进去逛一逛~

Java多线程

1. 进程与线程

线程：

线程是操作系统能够进行运算调度的最小单位。它被包含在进程中，是进程中的实际运作单位。
生命周期：

进程：

进程是程序的基本执行实体。

2. 多线程

1）相关概念

相关概念：

并发：在同一时刻，有多个指令在单个CPU上交替执行。
并行：在同一时刻，有多个指令在单个CPU上同时进行。

2) 多线程实现方式

①继承Thread类

多线程第一种实现方式：

①继承Thread类
②重写run方法
③创建子类的对象，并使用start()方法启动线程

/**
 * @author .29.
 * @create 2023-10-17 16:21
 */
public class extendThread {
    //1.自定义类，继承Thread类
    static class myThread extends Thread{
        //2.重写run方法，编写执行逻辑
        @Override
        public void run() {
            for(int i = 0;i < 100; ++i){
                System.out.println("执行：" + getName());
            }
        }
    }

    public static void main(String[] args){
        //3. 实现Thread子类对象，使用start()启动线程
        myThread t1 = new myThread();
        myThread t2 = new myThread();
        t1.setName("线程1号");
        t2.setName("线程2号");
        t1.start();
        t2.start();
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26

②实现Runnable接口

多线程第二种实现方式：

①自定义类，实现Runnable接口。
②重写接口中的run方法。
③实例化Runnable实现类
④以Runnable实现类对象为参数，创建Thread实例，开启线程。

public class implementsRunnable {
    //1.自定义类，实现Runnable接口
    static class myRun implements Runnable{
        //2.重写抽象方法
        @Override
        public void run() {
            //编写需要执行的程序
            for(int i = 0;i < 100; ++i){
                //获取当前执行的线程
                Thread t = Thread.currentThread();
                System.out.println("执行：" + t.getName());
            }

        }
    }

    public static void main(String[] args){
        //3.实例化Runnable实现类
        myRun mr = new myRun();

        //4.创建线程对象，使用start()启动线程
        Thread t1 = new Thread(mr);
        Thread t2 = new Thread(mr);
        t1.start();
        t2.start();

    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28

③利用Callable接口和Future接口

多线程第三种实现方式

特点： 可以获取到多线程运行的结果
①创建一个Callable接口的实现类
②重写Callable接口中的call方法（返回多线程执行的结果）
③创建Callable实现类对象（表示多线程要实现的任务）
④创建Future实现类FutureTask的对象（用于管理多线程运行的结果）
⑤创建Thread对象，并启动

/**
 * @author .29.
 * @create 2023-10-17 21:09
 */
public class implementsCallable {
    //1.创建Callable接口实现类，泛型指定返回的线程执行结果的类型
    static class myCall implements Callable<Integer>{
        //2.重写实现类方法
        @Override
        public Integer call() throws Exception {
            return 29;
        }
    }

    public static void main(String[] args) throws ExecutionException, InterruptedException {
        //3.实例化Callable实现类
        myCall call = new myCall();
        //4.创建FutureTask对象，管理多线程执行结果
        FutureTask<Integer> ft = new FutureTask<>(call);
        //5.创建线程，并启动
        Thread t1 = new Thread(ft);
        t1.start();

        //获取多线程运行的结果
        int result = ft.get();
        System.out.println(result);
    }
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29

④ 比较优缺点

3. Thread类常用方法

常用的成员方法：

String getName()：返回此线程名称
void setName(String name)：修改此线程名称
static Thread currentThread()：获取当前线程实例对象
static void sleep(long time)：让线程休眠指定时间（单位:毫秒）
setPriority(int newPriority)：设置线程的优先级
final int getPriority()：获取此线程的优先级，线程默认的优先级为5，优先级范围1-10，数字越大，优先级越高。
final void setDaemon(boolean on)：设置为守护线程，当其他的非守护线程执行完毕后，守护线程就没有存在的必要了，会陆续结束，不一定会执行完毕。
public static void yield()：出让线程/礼让线程

    //1.自定义类，继承Thread类
    static class myThread extends Thread{
        //2.重写run方法，编写执行逻辑
        @Override
        public void run() {
            for(int i = 0;i < 100; ++i){
                System.out.println("执行：" + getName());
                //出让CPU的执行权，即出让线程
                Thread.yield();
            }
        }
    }
1
2
3
4
5
6
7
8
9
10
11
12

public static void join()：插入线程/插队线程，将此线程插入到当前线程之前，只有插入的线程执行完毕，当前线程才会执行。

4. 线程安全

1) 同步代码块

格式：
- ```
synchronized(锁对象){
    //操作共享数据的代码
}
1
2
3
```
- 锁对象：可以是任意一个对象，但需要对象是唯一的，使用的锁不一样，没意义。建议使用当前类的字节码文件对象：Xxx.class
特点：
- ①锁默认是打开状态，有一个线程进去了，锁自动关闭。
- ②里面的代码全部执行完毕，线程出来，锁自动打开。

2) 同步方法

同步方法 —— 将synchronized关键字加到方法上。
格式：

修饰符 synchronized 返回值类型 方法名(方法参数){...}
1

特点：
- ①同步方法是锁住方法里面所有的代码。
- ②锁对象不能自己指定
- - 非静态方法的锁对象：this（当前方法的调用者）
  - 静态方法的锁对象：当前类的字节码文件对象（Xxx.class）

3) Lock锁

为了清晰表达如何加锁和释放锁，JDK5以后提供了一个新的锁对象Lock
Lock中提供了获取锁和释放锁的方法：
- void lock()——获得锁
- void unlock()——释放锁
Lock是接口，获取Lock对象需要实例化Lock的实现类ReentrantLock：
- ReentrantLock()——构造方法、创建一个ReentrantLock实例

注意： 为了保证锁的释放，当调用lock()获得锁后，后面执行的代码放入到try{}catch{}块中，之后在finally{}块中调用unLock()，因为finally块中代码一定会执行，也就保证了锁一定会被释放。

5. 等待唤醒机制（生产者和消费者）

常用方法：

void wait()：当前线程等待，直至被其他线程唤醒
void notify()：随机唤醒单个线程
void notifyAll()：唤醒所有线程

1) 生产者

生产者代码：

/**
 * @author .29.
 * @create 2023-10-18 21:18
 */
//继承Thread
public class Producer extends Thread{
    //重写run方法
    @Override
    public void run() {
        //1.循环
        while(true){
            //2. 同步代码块
            synchronized(Product.lock){
                if(Product.count == 0){
                    break;
                }else{
                    if(Product.flag == 0){ //货架没有商品
                        System.out.println("生产者生产商品"); //生产
                        Product.flag = 1;                   //上架（修改状态）
                        Product.lock.notifyAll();           //唤醒与锁绑定的所有线程

                    }else{
                        try {
                            Product.lock.wait(); //货架有商品，等待
                        } catch (InterruptedException e) {
                            e.printStackTrace();
                        }

                    }
                }
            }
        }
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34

商品货架:

/**
 * @author .29.
 * @create 2023-10-18 21:20
 */
public class Product {
    //总个数
    public static int count = 10;
    //消费者可否消费 0无产品，不可消费 1有产品，可消费
    public static int flag = 0;
    //锁对象
    public static Object lock = new Object();
}
1
2
3
4
5
6
7
8
9
10
11
12

2) 消费者

消费者代码：

/**
 * @author .29.
 * @create 2023-10-18 21:18
 */
//继承Thread
public class Consumer extends Thread{
    //重写run方法
    @Override
    public void run() {
        //1.循环
        while(true){
            //2.同步代码块
            synchronized(Product.lock){
                //3.判断货架是否上架了商品
                if(Product.flag == 0){
                    //没有商品线程进入等待
                    try {
                        Product.lock.wait();
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }else{
                    //可以消费，消费者进行消费，总数-1
                    Product.count--;
                    System.out.println("消费者消费商品，还可消费"+Product.count+"件商品");
                    //4. 通过锁，唤醒与锁绑定的所有线程
                    Product.lock.notifyAll();
                    //5. 修改货架状态
                    Product.flag = 0;
                }
            }
        }

    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35

测试：

/**
 * @author .29.
 * @create 2023-10-18 21:39
 */
public class Test {
    public static void main(String[] args){
        Producer producer = new Producer();
        Consumer consumer = new Consumer();

        producer.start();
        consumer.start();
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13

运行：

生产者生产商品
消费者消费商品，还可消费9件商品
生产者生产商品
消费者消费商品，还可消费8件商品
生产者生产商品
消费者消费商品，还可消费7件商品
生产者生产商品
消费者消费商品，还可消费6件商品
生产者生产商品
消费者消费商品，还可消费5件商品
生产者生产商品
消费者消费商品，还可消费4件商品
生产者生产商品
消费者消费商品，还可消费3件商品
生产者生产商品
消费者消费商品，还可消费2件商品
生产者生产商品
消费者消费商品，还可消费1件商品
生产者生产商品
消费者消费商品，还可消费0件商品
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20

3) 等待唤醒 —— 阻塞队列方式

阻塞队列继承结构：

Iterable 接口
Collection 接口
Queue 接口
BlockingQueue 接口
- ①ArrayBlockingQueue 实现类
- - 底层是数组，有界
- ②LinkedBlockingQueue实现类
- - 底层是链表，可看作无界，上限是int类型最大值