并发基础知识学习

原创已于 2024-01-16 21:07:45 修改 · 841 阅读

16 ·

CC 4.0 BY-SA版权

文章标签：

#学习 #java

于 2024-01-16 21:03:15 首次发布

Java基础语法专栏收录该内容

7 篇文章

订阅专栏

本文围绕Java多线程展开，先介绍CPU、进程和线程概念，接着阐述创建线程的六种方式，包括继承Thread类、实现Runnable接口等。还探讨线程安全性，如使用synchronized关键字、解决死锁问题等。最后介绍线程状态及线程协助方法，如wait、notify等。

一、多线程

CPU

CPU概述

CPU是指中央处理器，负责处理和执行指令，包含算术逻辑运算等。处理的主要过程

获取
解码
执行

CPU的组成

CPU主要由三部分组成

运算器：负责算术运算（+ - * / 基本运算和附加运算）和逻辑运算（包括移位、逻辑测试或比较两个值等）
寄存器：暂存指令、数据和地址。既要对接控制器的命令，传达命令给运算器；还要帮运算器记录处理完或者将要处理的数据
- 指令寄存器：保存当前正在执行的一条指令
- 数据寄存器：作为CPU和主存、外设之间信息传输的中转站
- 地址寄存器：保存CPU当前所访问的主存单元的地址
- 程序计数器：指出下一条指令在主存储器中的地址
- 累加寄存器：当运算器的算术逻辑单元ALU执行算术或逻辑运算时，为ALU提供一个工作区，可以为ALU暂时保存一个操作数或运算结果
- 程序状态字寄存器：当前运算的状态及程序的工作方式
控制器：负责应对所有的信息情况，调度运算器把计算做好

参考资料：https://www.cnblogs.com/gnivor/p/15679241.html

进程和线程

进程（Process）概述

进程是CPU资源分配的最小单位，拥有自己的独立地址空间。当可执行程序的实例被CPU读取加载到内存中，会生成一个进程
比如：点击游戏的.exe运行文件，CPU会把程序从磁盘加载到内存中，生成一个运行中的执行进程
执行文件加载到内存.png

线程（Thread）概述

线程是进程执行的最小单元，一个进程由一条或多条线程组成，一条线程内程序执行是顺序
每个CPU核心同时只能运行一个线程，不论这个线程是哪个进程的，即CPU会进行调度线程，以此来执行不同的进程

同步/异步概念

同步：程序执行按代码顺序
异步：程序执行过程中，存在并行分支，一般为进程中开启新的线程执行其它任务

创建线程

在java中创建线程有多种方式：

继承Thread类
实现Runnable接口
实现Callable接口、创建Feature类
创建匿名内部类
使用lambda表达式
创建Executor线程池

3.1 继承Thread类

创建线程实现类继承Thread类
重写run()方法，run()方法中是线程实际需要驱动的任务，即需要执行的代码块
线程启动需要显式的创建线程实现类，然后调用start()方法

注意点：

线程的实际运行应该调用start()方法，而不是显式的调用run()方法
线程创建后，并不会立即执行，而是处于就绪状态，然后等待CPU调度执行

代码示例：

public class ThreadTest01 extends Thread{
    private int count = 50;
    @Override
    public void run() {
        while (count > 0) {
            count--;
            System.out.println(Thread.currentThread().getName() + "执行后输出结果：" + count);
        }
    }

    public static void main(String[] args) {
        for (int i = 0; i < 3; i++) {
            new ThreadTest01().start();
        }
    }
}

输出结果：

Thread-1执行后输出结果：49
Thread-0执行后输出结果：49
Thread-0执行后输出结果：48
Thread-0执行后输出结果：47
Thread-0执行后输出结果：46
Thread-0执行后输出结果：45
Thread-0执行后输出结果：44
Thread-0执行后输出结果：43
Thread-2执行后输出结果：49
Thread-0执行后输出结果：42
...

3.2 实现Runnable接口

创建Runnable接口实现类实现Runnable接口
重写run()方法，run()方法中是线程实际需要驱动的任务，即需要执行的代码块
线程启动需要创建Thread类，并通过构造器注入Runnable接口实现类，最后再调用start()方法

代码示例：

public class ThreadTest02 implements Runnable{
    private int count = 50;
    @Override
    public void run() {
        while (count > 0) {
            count--;
            System.out.println(Thread.currentThread().getName()+"执行后输出结果"+count);
        }
    }

    public static void main(String[] args) {
        for (int i = 0; i < 3; i++) {
            // 通过构造器注入Runnable接口的实现类
            new Thread(new ThreadTest02()).start();
        }
    }
}

输出结果：

Thread-0执行后输出结果49
Thread-1执行后输出结果49
Thread-2执行后输出结果49
Thread-1执行后输出结果48
Thread-0执行后输出结果48
Thread-1执行后输出结果47
Thread-2执行后输出结果48
Thread-1执行后输出结果46
Thread-0执行后输出结果47
Thread-0执行后输出结果46
...

3.3 实现Callable接口、创建Feature类

创建Callable接口实现类实现Callable接口，可以指定返回的数据类型
重写call()方法，call()方法中是线程实际需要驱动的任务，即需要执行的代码块，并且会返回执行结果
创建FutureTask类，并通过构造器注入Callable接口实现类
线程启动需要创建Thread类，并通过构造器注入FutureTask类，最后再调用start()方法
可以通过FutureTask类的get()方法用于获取线程执行的结果

注意点：

Callable和Feature是基于JUC并发中的LockSupport实现的
用下面的例子来说明，可以简单理解为：mian线程如果要获取到子线程的返回结果，那它就必须等待子线程运行完成才能最终获取到子线程的执行结果

代码示例：

public class ThreadTest03 implements Callable<String> {
    private int count = 50;
    @Override
    public String call() throws Exception {
        while (count > 0) {
            count--;
            System.out.println(Thread.currentThread().getName()+"执行后输出结果"+count);
        }
        TimeUnit.SECONDS.sleep(3);
        return Thread.currentThread().getName() + "执行完毕：" + count;
    }

    public static void main(String[] args) {
        ThreadTest03 callable = new ThreadTest03();
        FutureTask<String> futureTask = new FutureTask<>(callable);
        new Thread(futureTask).start();
        String result = null;
        try {
            boolean done = futureTask.isDone();
            System.out.println("子任务是否执行完成：" + done);
            result = futureTask.get();
3            boolean done1 = futureTask.isDone();
            System.out.println("子任务是否执行完成：" + done1);
        } catch (InterruptedException e) {
            e.printStackTrace();
        } catch (ExecutionException e) {
            e.printStackTrace();
        }
        System.out.println(result);
    }
}

输出结果：

子任务是否执行完成：false
Thread-0执行后输出结果49
Thread-0执行后输出结果48
Thread-0执行后输出结果47
...
Thread-0执行后输出结果2
Thread-0执行后输出结果1
Thread-0执行后输出结果0
子任务是否执行完成：true
Thread-0执行完毕：0

3.4 创建匿名内部类

public class ThreadTest05 {
    public static void main(String[] args) {
        int[] count = {50};
        for (int i = 0; i < 3; i++) {
            new Thread(new Runnable() {
                @Override
                public void run() {
                    while (count[0] > 0) {
                        count[0]--;
                        System.out.println(Thread.currentThread().getName() + "执行后输出结果:" + count[0]);
                    }
                }
            }).start();
        }
    }
}

结果：

Thread-0执行后输出结果:48
Thread-1执行后输出结果:48
Thread-1执行后输出结果:46
Thread-1执行后输出结果:45
...
Thread-1执行后输出结果:0
Thread-0执行后输出结果:47
Thread-2执行后输出结果:44

3.5 使用lambda表达式

创建Thread对象，并且通过lambda表达式实现函数式接口，即实现Runnable接口

public class ThreadTest04 {

    public static void main(String[] args) {
        final int[] count = {50};
        for (int i = 0; i < 3; i++) {
            new Thread(() -> {
                while (count[0] > 0) {
                    count[0]--;
                    System.out.println(Thread.currentThread().getName() + ":" + count[0]);
                }
            }).start();
        }
    }
}

结果：

Thread-0:48
Thread-2:47
Thread-2:45
Thread-1:48
Thread-2:44
Thread-2:42
...

3.6 Executor线程池

创建一个实现类实现Runnable接口
通过Executor创建对应的线程池，并传入Runnable实现类
通过Executor的execute方法执行任务
通过Executor的shutDown方法销毁线程池

    public static void main(String[] args) {
        class ThreadExecutor implements Runnable {
            @Override
            public void run() {
                int[] count = {50};
                while (count[0] > 0) {
                    count[0]--;
                    System.out.println(Thread.currentThread().getName() + "执行后结果：" + count[0]);
                }
            }
        }

        /**
         * 创建一个线程池
         * 最多可以支持Integer.MAX_VALUE条线程（当线程可复用时，就会停止创建新的线程）
         * 线程空闲时间达60s后会被移除
         * 线程池使用完成后必须shutdown，否则会一直存活
         */
        ExecutorService service = Executors.newCachedThreadPool();
        for (int i = 0; i < 3; i++) {
            service.execute(new ThreadExecutor());
        }
        service.shutdown();

        /**
         * 创建一个线程池
         * 可以指定需要的线程数（当线程可复用时，就会停止创建新的线程）
         * 线程会一直存活
         * 线程池使用完成后必须shutdown，否则会一直存活
         */
//        ExecutorService service1 = Executors.newFixedThreadPool(5);
//        for (int i = 0; i < 3; i++) {
//            service1.execute(new ThreadExecutor());
//        }
//        service1.shutdown();

        /**
         * 创建一个线程数量为1线程池，一般用于同步执行
         * 线程会一直存活
         * 线程池使用完成后必须shutdown，否则会一直存活
         */
//        ExecutorService service2 = Executors.newSingleThreadExecutor();
//        for (int i = 0; i < 3; i++) {
//            service2.execute(new ThreadExecutor());
//        }
//        service2.shutdown();
    }

结果：

pool-1-thread-1执行后结果：49
pool-1-thread-3执行后结果：49
pool-1-thread-2执行后结果：49
pool-1-thread-3执行后结果：48

4. 线程的安全性

从之前的例子中可以观察到 count在执行自减和输出时存在数据安全问题
:::info
如何做到线程间数据同步，保证数据的安全？
:::

4.1 使用synchronized关键字

修饰代码块：指定加锁对象，默认是this锁，注意：使用的锁对象必须是同一个

private final Object lockObject = new Object();

synchronized (lockObject){
    
}

例子：

public class ThreadTest07 {
    private final Object lockObject = new Object();

    class ThreadExecutor implements Runnable {
        int count = 500;
        @Override
        public void run() {
            while (count > 1) {
                synchronized (lockObject) {
                    // count-- 在java中非原子操作，分为 读取 +1 写入
                    count--;
                    // 输出时需要读取count的值，可能也存在安全性问题
                    System.out.println(Thread.currentThread().getName() + "执行结果：" + count);
                }
            }
        }
    }

    public static void main(String[] args) {
        new ThreadTest07().testSync();
    }

    public void testSync() {
        ThreadExecutor executor = new ThreadExecutor();
        for (int i = 0; i < 3; i++) {
            // 同一个任务由不同线程驱动
            new Thread(executor).start();
            // 注意：不要这样写，实际是创建了三个任务，分别由不同线程驱动
//            new Thread(new ThreadExecutor());
        }
    }
}

this表示当前任务对象

public class ThreadTest08 {
    class ThreadExecutor implements Runnable {
        int count = 500;
        @Override
        public void run() {
            while (count > 1) {
                synchronized (this) {
                    // count-- 在java中非原子操作，分为 读取 +1 写入
                    count--;
                    // 输出时需要读取count的值，可能也存在安全性问题
                    System.out.println(Thread.currentThread().getName() + "执行结果：" + count);
                }
            }
        }
    }

    public static void main(String[] args) {
        new ThreadTest08().testSync();
    }

    public void testSync() {
        ThreadExecutor executor = new ThreadExecutor();
        for (int i = 0; i < 3; i++) {
            new Thread(executor).start();
            // 注意：不要这样写，实际是创建了三个任务，分别由不同线程驱动
//            new Thread(new ThreadExecutor());
        }
    }
}

修饰实例方法：使用的是this锁

private synchronized void execute() {
    
}

例子：

public class ThreadTest09 {
    class ThreadExecutor implements Runnable {
        int count = 500;
        @Override
        public void run() {
            while (count > 1) {
                process();
            }
        }

        public synchronized void process() {
            // count-- 在java中非原子操作，分为 读取 +1 写入
            count--;
            // 输出时需要读取count的值，可能也存在安全性问题
            System.out.println(Thread.currentThread().getName() + "执行结果：" + count);
        }
    }

    public static void main(String[] args) {
        new ThreadTest09().testSync();
    }

    public void testSync() {
        ThreadExecutor executor = new ThreadExecutor();
        for (int i = 0; i < 3; i++) {
            new Thread(executor).start();
            // 注意：不要这样写，实际是创建了三个任务，分别由不同线程驱动
//            new Thread(new ThreadExecutor());
        }
    }


}

修饰静态方法：使用当前类对象加锁，例如

private static synchronized void execute() {
    
}

列子：

public class ThreadTest10 {
    private static int count = 500;

    class ThreadExecutor implements Runnable {

        @Override
        public void run() {
            while (count > 1) {
                process();
                try {
                    TimeUnit.MILLISECONDS.sleep(20);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        }
    }
    public static synchronized void process() {
        // count-- 在java中非原子操作，分为 读取 +1 写入
        count--;
        // 输出时需要读取count的值，可能也存在安全性问题
        System.out.println(Thread.currentThread().getName() + "执行结果：" + count);
    }

    public static void main(String[] args) {
        new ThreadTest10().testSync();
    }

    public void testSync() {
        ThreadExecutor executor = new ThreadExecutor();
        for (int i = 0; i < 3; i++) {
            new Thread(executor).start();
            // 注意：不要这样写，实际是创建了三个任务，分别由不同线程驱动
//            new Thread(new ThreadExecutor());
        }
    }
}

加锁的缺点：

会影响程序执行的效率，因此加锁应该尽量覆盖可能发生线程安全的代码

4.2 死锁问题

主要在使用synchronized关键字时进行嵌套
出现死锁的几个必要条件：

互斥条件：共享资源a和共享资源b只能同时被一条线程占用
请求和持有条件：线程1持有共享资源a，并且在请求资源b，但是共享资源b被线程2持有且不释放
不可抢占条件：线程1持有共享资源a时，不能被其它线程强行抢占
循环等待条件：线程1等待线程2持有的共享资源b，且线程2等待线程1持有的共享资源a

例子：

public class ThreadTest12 {
    class ThreadExecutor implements Runnable {
        private final Object lockObject = new Object();
        int count = 500;
        @Override
        public void run() {
            while (true) {
                if (count % 2 == 0) {
                    synchronized (this) {
                        execute1();
                    }
                } else {
                    synchronized (lockObject) {
                        execute2();
                    }
                }

            }
        }

        public void execute1() {
            synchronized (lockObject) {
                // count-- 在java中非原子操作，分为 读取 +1 写入
                count--;
                // 输出时需要读取count的值，可能也存在安全性问题
                System.out.println(Thread.currentThread().getName() + "执行结果：" + count);
            }
        }

        public void execute2() {
            synchronized (this) {
                // count-- 在java中非原子操作，分为 读取 +1 写入
                count--;
                // 输出时需要读取count的值，可能也存在安全性问题
                System.out.println(Thread.currentThread().getName() + "执行结果：" + count);
            }
        }
    }

    public static void main(String[] args) {
        new ThreadTest12().testSync();
    }

    public void testSync() {
        ThreadExecutor executor = new ThreadExecutor();
        for (int i = 0; i < 3; i++) {
            new Thread(executor).start();
            // 注意：不要这样写，实际是创建了三个任务，分别由不同线程驱动
//            new Thread(new ThreadExecutor());
        }
    }
}

:::info
怎么判断哪里出现死锁？
:::

找到jdk安装目录下的jconsole.exe

C:\Program Files\Java\jdk1.8.0_351\bin\jconsole.exe

点击上方导航栏的线程，然后检测死锁

4.3 使用ReentrantLock

声明ReentrantLock对象
在执行存在数据安全的代码前，调用ReentrantLock的lock方法进行加锁，注意需要使用try-finally包裹
需要在finally中使用ReentrantLock的unlock方法释放锁

例子：

public class ThreadTest11 {
    private final ReentrantLock lock = new ReentrantLock();
    class ThreadExecutor implements Runnable {
        int count = 500;
        @Override
        public void run() {
            while (count > 1) {
                try {
                    // 获取锁资源然后执行操作
                    lock.lock();
                    // count-- 在java中非原子操作，分为 读取 +1 写入
                    count--;
                    // 输出时需要读取count的值，可能也存在安全性问题
                    System.out.println(Thread.currentThread().getName() + "执行结果：" + count);
                } finally {
                    // 释放锁
                    lock.unlock();
                }
                try {
                    // 线程睡眠30ms，便于观察线程之间的切换
                    TimeUnit.MILLISECONDS.sleep(30);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        }
    }

    public static void main(String[] args) {
        new ThreadTest11().testSync();
    }

    public void testSync() {
        ThreadExecutor executor = new ThreadExecutor();
        for (int i = 0; i < 3; i++) {
            new Thread(executor).start();
            // 注意：不要这样写，实际是创建了三个任务，分别由不同线程驱动
//            new Thread(new ThreadExecutor());
        }
    }
}

5. 线程的状态

初始化状态（新建状态）：即java代码中创建一个线程Thread对象
就绪状态：即线程Thread调用start方法
运行状态：即线程Thread被CPU调度后执行run方法
终止状态：即线程Thread执行完毕run方法
阻塞状态：即线程Thread竞争锁失败后会进入阻塞
等待：即线程Thread调用wait方法暂时被挂起，让出CPU执行权，会释放当前占有的锁对象

6. 线程协助

6.1 线程等待wait

使用wait方法需要结合synchronized关键字，否则会提示java.lang.IllegalMonitorStateException
使用wait方法需要通过锁对象来调用，否则也会提示java.lang.IllegalMonitorStateException

public class ThreadTest13 {
    private final Object lockObject = new Object();

    class ThreadExecutor implements Runnable {
        int count = 50;
        @Override
        public void run() {
            synchronized (lockObject) {
                try {
                    lockObject.wait();
                    System.out.println(Thread.currentThread().getName() + "执行wait()方法结束");
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                while (count > 1) {
                    // count-- 在java中非原子操作，分为 读取 +1 写入
                    count--;
                    // 输出时需要读取count的值，可能也存在安全性问题
                    System.out.println(Thread.currentThread().getName() + "输出count结果：" + count);
                }
            }
        }
    }

    public static void main(String[] args) {
        new ThreadTest13().testSync();
    }

    public void testSync() {
        ThreadExecutor executor = new ThreadExecutor();

        new Thread(executor).start();
        try {
            // 主线程睡眠5s，保证子线程可以先触发wait
            TimeUnit.SECONDS.sleep(5);
            System.out.println(Thread.currentThread().getName() + "睡眠5s");
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println(Thread.currentThread().getName() + "尝试获取lockObject锁");

        // 获取当前lockObject锁，然后主线程进行释放锁，并且通知所有等待lockObject锁的其它线程
        synchronized (this.lockObject) {
            System.out.println("获取lockObject锁成功，准备通知其它等待的线程");
            lockObject.notify();
        }

    }
}

结果：

main睡眠5s
main尝试获取lockObject锁
获取lockObject锁成功，准备通知其它等待的线程
Thread-0执行wait()方法结束
Thread-0输出count结果：49
Thread-0输出count结果：48
Thread-0输出count结果：47
...

6.2 线程唤醒notify

使用notify方法需要结合synchronized关键字，否则会提示java.lang.IllegalMonitorStateException
使用notify方法需要通过锁对象来调用，否则也会提示java.lang.IllegalMonitorStateException

6.3 线程加入join

在某个线程内调用join方法会导致该线程进入阻塞状态
join方法底层实际调用了wait方法（说明当前线程获取了this锁，然后调用了wait方法，进入阻塞状态）
当join新加入的线程执行完成后，虚拟机自己会唤醒所有在等待this锁的线程

例子：

public class ThreadTest14 {

    public static void main(String[] args) {

        Thread t1 = new Thread(() -> {
            StopWatch stopWatch = new StopWatch("t1");
            stopWatch.start();
            try {
                TimeUnit.SECONDS.sleep(2);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println(Thread.currentThread().getName());
            stopWatch.stop();
            System.out.println("执行耗时：StopWatch 't1': running time = " + stopWatch.getTotalTimeSeconds());
        });
        Thread t2 = new Thread(() -> {
            StopWatch stopWatch = new StopWatch("t2");
            stopWatch.start();
            try {
                TimeUnit.SECONDS.sleep(4);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            try {
                t1.join();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }

            System.out.println(Thread.currentThread().getName());
            stopWatch.stop();
            System.out.println("执行耗时：StopWatch 't2': running time = " + stopWatch.getTotalTimeSeconds());
        });
        Thread t3 = new Thread(() -> {
            StopWatch stopWatch = new StopWatch("t3");
            stopWatch.start();
            try {
                t2.join();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println(Thread.currentThread().getName());
            stopWatch.stop();
            System.out.println("执行耗时：StopWatch 't3': running time = " + stopWatch.getTotalTimeSeconds());
        });

        t1.start();
        t2.start();
        t3.start();
        try {
            TimeUnit.SECONDS.sleep(4);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println(Thread.currentThread().getName()+"主线程执行结束");
    }
}

6.4 线程睡眠sleep

使当前线程休眠指定时间，不会释放锁

        try {
            TimeUnit.SECONDS.sleep(5);
            System.out.println(Thread.currentThread().getName() + "睡眠5s");
        } catch (InterruptedException e) {
            e.printStackTrace();
        }

        try {
            Thread.Sleep(5);
            System.out.println(Thread.currentThread().getName() + "睡眠5s");
        } catch (InterruptedException e) {
            e.printStackTrace();
        }