并发编程(二) 线程

约定不等于承诺〃 2023-10-01 20:07 10阅读 0赞

### 1、java线程 ###

Java程序天生就是一个多线程的程序，每个Java程序都至少有一个线程，即主线程，当Java程序启动时，JVM会创建主线程，同时，还会创建一系列其他的线程，例如：垃圾收集、对象终止和其它 JVM 内部处理任务相关的线程。

2、线程状态  
![在这里插入图片描述][watermark_type_d3F5LXplbmhlaQ_shadow_50_text_Q1NETiBA56iL5bqP5ZGY6ICB55-z_size_20_color_FFFFFF_t_70_g_se_x_16_pic_center]

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

*  新建：当一个Thread类或其子类的对象被声明并创建时，新生的线程对象处于新建状态
 *  就绪：处于新建状态的线程被`start()`后，将进入线程队列等待CPU时间片，此时它已具备了运行的条件，只是没分配到CPU资源
 *  运行：当就绪的线程被调度并获得CPU资源时,便进入运行状态，`run()`方法定义了线程的操作和功能
 *  阻塞：在某种特殊情况下，被人为挂起或执行输入输出操作时，让出CPU并临时中止自己的执行，进入阻塞状态
 *  死亡：线程完成了它的全部工作或线程被提前强制性地中止或出现异常导致结束

**线程的生命周期**  
![在这里插入图片描述][watermark_type_d3F5LXplbmhlaQ_shadow_50_text_Q1NETiBA56iL5bqP5ZGY6ICB55-z_size_20_color_FFFFFF_t_70_g_se_x_16_pic_center 1]

注意：

*  **join()：当在A线程中调用B线程的join()方法，阻塞的是A线程**

Java线程线程转换图如上图所示。

线程创建之后调用`start()`方法开始运行，当调用`wait()`，`join()`，`LockSupport.lock()`方法线程会进入到`WAITING`状态，而同样的`wait(long timeout)`，`sleep(long)`，`join(long)`，`LockSupport.parkNanos()`，`LockSupport.parkUtil()`增加了超时等待的功能，也就是调用这些方法后线程会进入`TIMED_WAITING`状态，当超时等待时间到达后，线程会切换到`Runnable`的状态，另外当`WAITING`和`TIMED_WAITING`状态时可以通过`Object.notify()`,`Object.notifyAll()`方法使线程转换到`Runable`状态。当线程出现资源竞争时，即等待获取锁的时候，线程会进入到`BLOCKED`阻塞状态，当线程获取锁时，线程进入到`Runnable`状态。

线程运行结束后，线程进入到`TERMINATED`状态，状态转换可以说是线程的生命周期。另外需要注意的是：

*  当线程进入到`synchronized`方法或者`synchronized`代码块时，线程切换到的是`BLOCKED`状态，而使用`java.util.concurrent.locks`下`lock`进行加锁的时候线程切换的是`WAITING`或者`TIMED_WAITING`状态，因为`lock`会调用`LockSupport`的方法。

<table> 
 <thead> 
  <tr> 
   <th>状态名称</th> 
   <th>说明</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td>NEW</td> 
   <td>初始状态，线程被构建，但是还没有调用start()方法</td> 
  </tr> 
  <tr> 
   <td>RUNNABLE</td> 
   <td>运行状态，Java线程将操作系统中的就绪和运行两种状态笼统称为“运行中”</td> 
  </tr> 
  <tr> 
   <td>BLOCKED</td> 
   <td>阻塞状态，表示线程阻塞于锁</td> 
  </tr> 
  <tr> 
   <td>WAITTING</td> 
   <td>等待状态，表示线程进入等待状态，进入该状态表示当前线程需要等待其他线程做出一些特定的动作（通知或者中断）</td> 
  </tr> 
  <tr> 
   <td>TIMED_WAITING</td> 
   <td>超时等待状态，该状态不同于WAITTING，它是可以在指定的时间自行返回的</td> 
  </tr> 
  <tr> 
   <td>TERMINATED</td> 
   <td>终止状态，表示当前线程已经执行完毕</td> 
  </tr> 
 </tbody> 
</table>

### 2、线程同步 ###

#### 2.1 同步问题分析 ####

1、提出问题： 
     多个线程执行的不确定性引起执行结果的不稳定
     多个线程对账本的共享，会造成操作的不完整性，会破坏数据。

![在这里插入图片描述][watermark_type_d3F5LXplbmhlaQ_shadow_50_text_Q1NETiBA56iL5bqP5ZGY6ICB55-z_size_20_color_FFFFFF_t_70_g_se_x_16_pic_center 2]

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

@Slf4j
    public class Windows{
        
    
        public static void main(String[] args) {
        
            Window01 window01 = new Window01();
    
            Thread t1 = new Thread(window01);
            Thread t2 = new Thread(window01);
            Thread t3 = new Thread(window01);
    
            t1.start();
            t2.start();
            t3.start();
    
        }
    
        /**
         * 加上Sleep让线程的切换的概率增大了
         */
        static class Window01 implements Runnable{
        
            private int ticket = 100;
            @Override
            public void run() {
        
                while (true){
        
                    try {
        
                        Thread.sleep(100);
                    } catch (InterruptedException e) {
        
                        e.printStackTrace();
                    }
                    if(ticket > 0){
        
                        log.info(Thread.currentThread().getName()+ ": 买票，票号为：{}",ticket);
                        ticket --;
                    }else{
        
                        break;
                    }
                }
            }
        }
    
    }

**打印结果：**  
![在这里插入图片描述][watermark_type_d3F5LXplbmhlaQ_shadow_50_text_Q1NETiBA56iL5bqP5ZGY6ICB55-z_size_20_color_FFFFFF_t_70_g_se_x_16_pic_center 3]

*  **问题出现的原因**：当某个线程操作车票的过程中，尚未操作完成时，其他线程参与进来，也操作车票
 *  **如何解决**：当一个线程a在操作ticket的时候，其他线程不能参与进来，直到线程a操作完ticket时，其他线程才可以开始操作ticket。这种情况即使线程a出现了阻塞，也不能被改变。
 *  在java中，通过同步机制解决线程安全问题
    
     *  方式一：同步代码块
        
            synchronized(同步监视器){
            		// 需要被同步的代码
            	}
        
        **说明：1、操作共享数据的代码即为需要被同步的代码。**
        
        **2、共享数据:多个线程共同操作的变量，ticket就是共享数据**
        
        **3、同步监视器：俗称锁。任何一个类的对象，都可以充当锁**  
        要求：多个线程必须要共用同步把锁。

#### 2.2 同步代码块处理实现Runnable的线程安全问题 ####

/**
     *  例子：创建三个窗口卖票，总票数为100张.使用实现Runnable接口的方式
     *  1.卖票过程中出现重票、错票 ---》出现了线程的安全问题
     *  2.问题出现的原因:当某个线程操作车票的过程中，尚未操作完成时，其他线程参与进来，也操作车票
     *  3.如何解决：当一个线程在操作ticket的时候，其他线程不能参与进来。直到线程a操作完ticket时，其他
     *            线程才可以操作ticket。这种情况即使线程a出现了阻塞，也不能被改变。
     *  4.在java中，我们通过同步机制，来解决线程的安全问题。
     *
     *  方式一：同步代码块
     *  synchronized(同步监视器){
     *      //需要被同步的代码
     *
     *  }
     *  说明：1.操作共享数据的代码，即为需要被同步的代码 --->不能包含代码多了，也不能包含代码少了。
     *       2.共享数据：多个线程共同操作的变量。比如：ticket就是共享数据
     *       3.同步监视器，俗称：锁。任何一个类的对象，都可以来充当锁。
     *          要求：多个线程必须要共用同一把锁。
     *
     *       补充：在实现Runnable接口创建多线程的方式中，我们可以考虑使用this充当同步监视器。
     *
     *  方式二：同步方法
     *      如果操作共享数据的代码完整的声明在一个方法中，我们不妨将此方法声明同步的
     *
     *  5.同步的方式，解决了线程的安全问题。---好处
     *    操作同步代码时，只能有一个线程参与，其他线程等待。相当于是一个单线程的过程，效率低。---局限性
     */
    
    class Windows1 implements Runnable{
        
    
        private int ticket = 100;
    //    Object obj = new Object();
    //    Dog dog = new Dog();
    
        @Override
        public void run() {
        
            while(true){
        
                synchronized (this) {
        //此时的this:唯一的windows1的对象 //方式二:synchronized (dog) {
        
                    if (ticket > 0) {
        
    
                        try{
        
                            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();
        }
    }
    class Dog{
        
    
    }

#### 2.3 同步代码块处理继承Thread类的线程安全问题 ####

**在继承Thread类创建多线程的方式中，慎用this充当同步监视器，考虑使用当前类充当同步监视器**

/**
     * 使用同步代码块解决继承Thread类的方式的线程安全问题
     *
     * 例子：创建三个c窗口卖票，总票数为100张
     */
    class Windows extends Thread{
        
    
        private static int ticket = 100;
        private static Object obj = new Object();
    
        @Override
        public void run() {
        
            while(true){
        
                //正确的
    //            synchronized (obj) {
        
                synchronized (Windows.class){
           //Class clazz = Windows.class
                //错误的，因为此时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();
        }
    }

#### 2.4 同步方法处理实现Runnable的线程安全问题 ####

/**
     * 使用同步方法解决实现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();
        }
    }

#### 2.5 同步方法处理继承Thread类的线程安全问题 ####

/**
     * 使用同步方法处理继承Thread类的方式中的线程安全问题
     */
    class Windows4 extends Thread {
        
    
        private static int ticket = 100;
    
        @Override
        public void run() {
        
    
            while (true) {
               
                show();
            }   
        }
        
        private static synchronized void show(){
        //同步监视器：Window4.class
            //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();
    
        }
    }

#### 2.6 线程安全的单例模式之懒汉式 ####

/**
     * 使用同步机制将单例模式中的懒汉式改写为线程安全的
     */
    public class BankTest {
        
    }
    class Bank{
        
    
        private Bank(){
        }
    
        private static Bank instance = null;
    
        public static Bank getInstance(){
        
            //方式一：效率稍差
            //快捷键:Alt+Shift+Z
    //        synchronized (Bank.class) {
        
    //            if(instance == null){
        
    //                instance = new Bank();
    //            }
    //            return instance;
    //        }
    
            //方式二：效率较高
            if(instance == null) {
        
                synchronized (Bank.class) {
        
                    if (instance == null) {
        
                        instance = new Bank();
                    }
                }
            }
            return instance;
        }
    }

### 3、线程通信 ###

/**
     * 线程通信的例子：使用两个线程打印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) {
        
                    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();
        }
    }

#### 3.1 Sleep()和wait()方法区别 ####

**1.相同点：**

一旦执行方法，都可以使得当前的线程进入阻塞状态。

**2.不同点：**

1）两个方法声明的位置不同：**Thread类中声明sleep() , Object类中声明wait()**

2）调用的要求不同：**sleep()可以在任何需要的场景下调用。 wait()必须使用在同步代码块或同步方法中**

3）关于是否释放同步监视器：**如果两个方法都使用在同步代码块或同步方法中，sleep()不会释放锁，wait()会释放锁**。

[watermark_type_d3F5LXplbmhlaQ_shadow_50_text_Q1NETiBA56iL5bqP5ZGY6ICB55-z_size_20_color_FFFFFF_t_70_g_se_x_16_pic_center]: https://img-blog.csdnimg.cn/3df9b2d44f46406bb37d178cadf4d74b.png?x-oss-process=image/watermark,type_d3F5LXplbmhlaQ,shadow_50,text_Q1NETiBA56iL5bqP5ZGY6ICB55-z,size_20,color_FFFFFF,t_70,g_se,x_16#pic_center
[watermark_type_d3F5LXplbmhlaQ_shadow_50_text_Q1NETiBA56iL5bqP5ZGY6ICB55-z_size_20_color_FFFFFF_t_70_g_se_x_16_pic_center 1]: https://img-blog.csdnimg.cn/0f1c408553ca4d348ef26581b4a17db5.png?x-oss-process=image/watermark,type_d3F5LXplbmhlaQ,shadow_50,text_Q1NETiBA56iL5bqP5ZGY6ICB55-z,size_20,color_FFFFFF,t_70,g_se,x_16#pic_center
[watermark_type_d3F5LXplbmhlaQ_shadow_50_text_Q1NETiBA56iL5bqP5ZGY6ICB55-z_size_20_color_FFFFFF_t_70_g_se_x_16_pic_center 2]: https://img-blog.csdnimg.cn/4878ee690e774d9296516a4377cc9243.png?x-oss-process=image/watermark,type_d3F5LXplbmhlaQ,shadow_50,text_Q1NETiBA56iL5bqP5ZGY6ICB55-z,size_20,color_FFFFFF,t_70,g_se,x_16#pic_center
[watermark_type_d3F5LXplbmhlaQ_shadow_50_text_Q1NETiBA56iL5bqP5ZGY6ICB55-z_size_20_color_FFFFFF_t_70_g_se_x_16_pic_center 3]: https://img-blog.csdnimg.cn/4dce605a9430485f84cbe90b200af29f.png?x-oss-process=image/watermark,type_d3F5LXplbmhlaQ,shadow_50,text_Q1NETiBA56iL5bqP5ZGY6ICB55-z,size_20,color_FFFFFF,t_70,g_se,x_16#pic_center