Java多线程05——JUC并发包01

痛定思痛。 2024-03-27 15:17 57阅读 0赞

## 1 JUC并发包 ##

JUC 即 `java.util.concurrent` 类的简称。主要为并发编程提供了许多通用工具类。

## 2 线程的 ThreadLocal 本地缓存对象 ##

线程范围内的共享变量，每个线程只能访问自己的数据，而不能访问其它线程数据。  
每个线程调用全局 `ThreadLocal` 对象的 set 方法，相当于往其内部的 map 中增加一条记录，key 分别是各自的线程，value 是各自的set方法传进去的值。

### 2.1 创建线程类及 ThreadLocal 对象 ###

import java.util.Random;
    
    public class UserRunn implements Runnable {
        //声明一个本地变量
        private ThreadLocal<Person> userThreadLocal = new ThreadLocal<>();
    
        @Override
        public void run() {
            System.out.println(Thread.currentThread().getName() + " 进入到run方法");
    
            Person person = getPerson();
            int age = new Random().nextInt(100);
            System.out.println(Thread.currentThread().getName() + " 产生的年龄是：" + age);
    
    
            System.out.println(Thread.currentThread().getName() + " 设置的年龄之前是" + person.getAge() + " 内存地址是" + person);
    
            try {
                Thread.sleep(2000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            person.setAge(age);
            System.out.println(Thread.currentThread().getName() + " 设置的年龄之后是" + person.getAge() + " 内存地址是" + person);
        }
    
        public Person getPerson(){
            Person u = userThreadLocal.get();
            if(u == null){
                u = new Person();
                userThreadLocal.set(u);
            }
            return u;
        }
    }
    
    class Person{
        private int age;
        private String name;
    
        public int getAge() {
            return age;
        }
    
        public void setAge(int age) {
            this.age = age;
        }
    }

### 2.2 创建测试类 ###

public class Test {
        public static void main(String[] args) {
            UserRunn userRunn = new UserRunn();
            new Thread(userRunn).start();
            new Thread(userRunn).start();
        }
    }

### 2.3 运行后输出如下： ###

> Thread-0 进入到run方法  
> Thread-1 进入到run方法  
> Thread-0 产生的年龄是：88  
> Thread-0 设置的年龄之前是0 内存地址是com.thread3.Person@6e0cc262  
> Thread-1 产生的年龄是：45  
> Thread-1 设置的年龄之前是0 内存地址是com.thread3.Person@6fec3797  
> Thread-1 设置的年龄之后是45 内存地址是com.thread3.Person@6fec3797  
> Thread-0 设置的年龄之后是88 内存地址是com.thread3.Person@6e0cc262

两个线程虽使用了同一个 `Runnable` 实体类进行了初始化，  
但因为使用了 `ThreadLocal` 对象，对不同线程间的数据，进行了隔离，  
因此可以看到，两个线程的数据彼此毫无关联。  
![在这里插入图片描述][9422216a70d44a7f81e6c96dc58a2fa2.png]

## 3 线程的 `volatile` 关键字 ##

`volatile` 关键字可以用来修饰字段（成员变量），作用是告诉程序，任何对该变量的访问均需要从共享内存中获取，而对它的改变必须同步刷新回共享内存，它能保证所有线程对变量访问的可见性。

### 3.1 创建线程类 ###

当标识符未发生变化时，线程将进入死循环

public class UserThread extends Thread {
        private volatile boolean flag = true;
    
        public boolean isFlag() {
            return flag;
        }
    
        public void setFlag(boolean flag) {
            this.flag = flag;
        }
    
        @Override
        public void run() {
            System.out.println(Thread.currentThread().getName() + "线程正在运行");
    
            while (flag){
            }
    
            System.out.println(Thread.currentThread().getName() + "线程运行结束");
        }
    }

### 3.2 创建测试类 ###

在主线程中修改线程类的循环标识符

public class Test {
        public static void main(String[] args) {
            UserThread userThread = new UserThread();
            userThread.start();
    
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            //修改子线程死循环的标识位，终止循环
            userThread.setFlag(false);
        }
    }

### 3.3 执行输出 ###

> Thread-0线程正在运行  
> Thread-0线程运行结束

`volatile` 的作用：使变量在多个线程间可见，但是未对数据加锁，无法保证数据的原子性或是一致性。  
需要注意的是，一般 `volatile` 用于只针对多个线程可见的变量操作，并不能代替 `synchronized` 的同步功能。

### 3.4 验证 `volatile` 与 `synchronized` 的区别 ###

#### 使用 `volatile` 修饰变量 ####

public class VolatileThread extends Thread {
        private static volatile int m = 0;
    
        @Override
        public void run() {
            for(int i=0;i<10;i++){
                m = m + 1;
                try {
                    //增加随机性
                    sleep(3);
                }catch (Exception e){
                }
            }
        }
    
        public static void main(String[] args) throws Exception{
            //初始化线程
            VolatileThread[] volatileThreads = new VolatileThread[100];
            for(int i =0;i<volatileThreads.length;i++){
                volatileThreads[i] = new VolatileThread();
            }
            //启动线程
            for(int i =0;i<volatileThreads.length;i++){
                volatileThreads[i].start();
            }
            //合并线程到主线程
            for(int i =0;i<volatileThreads.length;i++){
                volatileThreads[i].join();
            }
            System.out.println("m=" + VolatileThread.m);
        }
    }

执行结果：

> 始终小于1000

#### 修改为 `synchronized` 同步代码块 ####

public class VolatileThread extends Thread {
        private static volatile int m = 0;
    
        private static synchronized void mplus() {
            m = m + 1;
        }
    
        @Override
        public void run() {
            for(int i=0;i<10;i++){
                mplus();
                try {
                    //增加随机性
                    sleep(3);
                }catch (Exception e){
                }
            }
        }
    
        public static void main(String[] args) throws Exception{
            //初始化线程
            VolatileThread[] volatileThreads = new VolatileThread[100];
            for(int i =0;i<volatileThreads.length;i++){
                volatileThreads[i] = new VolatileThread();
            }
            //启动线程
            for(int i =0;i<volatileThreads.length;i++){
                volatileThreads[i].start();
            }
            //合并线程到主线程
            for(int i =0;i<volatileThreads.length;i++){
                volatileThreads[i].join();
            }
            System.out.println("m=" + VolatileThread.m);
        }
    }

执行结果：

> m=1000

## 4 线程池的作用和应用 ##

### 4.1 线程池的作用 ###

*  降低资源消耗  
    通过重复利用已创建的线程，降低线程创建和销毁造成的消耗。
 *  提高响应速度  
    当任务到达时，任务可以不需要等到线程创建就能立即执行。
 *  提高线程的可管理性  
    线程是稀缺资源，如果无限制的创建，不仅会消耗系统资源，还会降低系统的稳定性，使用线程池可以进行统一的分配，调优和监控。

### 4.2 线程池的应用 ###

场景：请求频繁，考虑到服务的并发问题，如果每个请求到来后，服务都为它启动一个线程，对于服务的资源可能会造成很大的浪费。

#### 4.2.1 创建线程资源 ####

import java.io.BufferedReader;
    import java.io.IOException;
    import java.io.InputStreamReader;
    import java.io.PrintWriter;
    import java.net.Socket;
    import java.util.UUID;
    
    public class WorkThread extends Thread {
        private Socket socket;
    
        public WorkThread(Socket socket){
            this.socket = socket;
        }
    
        @Override
        public void run() {
            try {
                //服务器接收客户端消息
                BufferedReader br = new BufferedReader(new InputStreamReader(socket.getInputStream()));
                String in = br.readLine();
                System.out.println(Thread.currentThread().getName() + " 服务器接收客户端的消息为： " + in);
    
                //服务器向客户端发送消息
                PrintWriter pw = new PrintWriter(socket.getOutputStream());
                pw.println("消息已收到" + UUID.randomUUID());
                pw.flush();//立即发送
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
    }

#### 4.2.2 创建客户端 ####

import java.io.*;
    import java.net.Socket;
    
    public class Client {
        Socket socket;
    
        public Client(){
            try {
                socket = new Socket("127.0.0.1", 8888);
                System.out.println("客户端和服务器建立连接成功");
                System.out.println("请客户端在控制台发送消息");
    
                //客户端构建消息
                BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
                String line = br.readLine();
                //客户端发送消息
                PrintWriter pw = new PrintWriter(socket.getOutputStream());
                pw.println(line);
                pw.flush();//立即发送消息
                //接收消息
                BufferedReader br1 = new BufferedReader(new InputStreamReader(socket.getInputStream()));
                String in = br1.readLine();
                System.out.println("客户端接收的消息为： " + in);
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
    
        public static void main(String[] args) {
            new Client();
        }
    }

#### 4.2.3 创建服务端 ####

import java.net.ServerSocket;
    import java.net.Socket;
    import java.util.concurrent.ExecutorService;
    import java.util.concurrent.Executors;
    
    public class Server {
        private Socket socket;
        private ServerSocket serverSocket;
    
        public Server(){
            System.out.println("服务器启动");
            try {
                serverSocket = new ServerSocket(8888);
                ExecutorService executorService = Executors.newFixedThreadPool(3);
                while (true){
                    socket = serverSocket.accept();
                    //每个客户端访问都会创建一个新的线程
                    //new WorkThread(socket).start();
                    
                    //使用线程池，可以对线程进行复用
                    executorService.execute(new WorkThread(socket));
                }
            } catch (Exception e) {
                e.printStackTrace();
            }
        }
    
        public static void main(String[] args) {
            new Server();
        }
    }

其中在 Server 中的 `new WorkThread(socket).start();` 写法会导致每一个连接创建一个线程，最终将导致服务器资源枯竭。

而采用线程池，可以很好地规避这个问题。

[9422216a70d44a7f81e6c96dc58a2fa2.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/27/8dd756b59f424e118396d0c2be227dd8.png