Java学习之线程进阶

以你之姓@ 2024-04-08 08:38 69阅读 0赞

上一篇分享了线程的基本概念和创建线程的方法，以及简单应用，下边分享一下进阶内容。

#### 线程的同步和锁 ####

Java是支持多线程的，那么什么是多线程呢？  
**并发执行机制原理**

> 简单地说就是把一个处理器划分为若干个短的时间片，每个时间片依次轮流地执行处理各个应用程序，由于一个时间片很短，相对于一个应用程序来说，就好像是处理器在为自己单独服务一样，从而达到多个应用程序在同时进行的效果。

**多线程**

> 就是把操作系统中的这种并发执行机制原理运用在一个程序中，把一个程序划分为若干个子任务，多个子任务并发执行，每一个任务就是一个线程。这就是多线程程序。

我们了解了多线程，再来看看Java的多线程并发时容易出现哪些问题  
下边看一个案例：  
需求：要求模拟火车站售票场景，三个窗口同时发售50张火车票。

class MySync implements Runnable{
        
        int ticket = 50;
    
        @Override
        public void run() {
        
            while (true){
        
                if (ticket > 0){
        
                    System.out.println(Thread.currentThread().getName() + "售票："+ ticket+"号");
                    ticket--;
                }else {
        
                    System.out.println("售罄");
                    break;
                }
            }
        }
    }
    public class Demo5 {
        
        public static void main(String[] args) {
        
            MySync mySync = new MySync();
            Thread thread1 = new Thread(mySync,"一号");
            thread1.start();
            Thread thread2 = new Thread(mySync,"二号");
            thread2.start();
            Thread thread3 = new Thread(mySync,"三号");
            thread3.start();
        }
    }

执行结果：  
![在这里插入图片描述][0c31319ad38f4d65b282632810a8a8a9.png]  
可以看到，结果并没有像我们预期的那样，反而出现了不合常理的BUG，50号车票被每一个窗口都售出一次，这显然是错误的。我们来了解一种新的概念。

##### 使用同步方法 #####

由于三个窗口对于同一个数据的引用并没有做到同步，所以导致出现了BUG。对于这个问题，Java给我们提供了一个同步方法，使用synchronized关键字来修饰方法。

class MySync implements Runnable{
        
        int ticket = 50;
    
        @Override
        public synchronized void run() {
        
            while (true){
        
                if (ticket > 0){
        
                    System.out.println(Thread.currentThread().getName() + "售票："+ ticket+"号");
                    ticket--;
                }else {
        
                    System.out.println("售罄");
                    break;
                }
            }
        }
    }
    public class Demo5 {
        
        public static void main(String[] args) {
        
            MySync mySync = new MySync();
            Thread thread1 = new Thread(mySync,"一号");
            thread1.start();
            Thread thread2 = new Thread(mySync,"二号");
            thread2.start();
            Thread thread3 = new Thread(mySync,"三号");
            thread3.start();
        }
    }

执行结果：  
![在这里插入图片描述][1ff0cf767cb6401e8d9a5b1d8d1e2a31.png]  
![在这里插入图片描述][019d61509f7f41b8832767baeaa81be1.png]  
出现一个窗口一直将票卖完的情况，和我们预想的结果还是有些差距。需要再进行优化一下

class MySync1 implements Runnable{
        
        int ticket = 50;
    
        @Override
        public  void run() {
        
            while (true){
        
               synchronized (this){
        
                   if (ticket > 0){
        
                       System.out.println(Thread.currentThread().getName() + "售票："+ ticket+"号");
                       ticket--;
                   }else {
        
                       System.out.println("售罄");
                       break;
                   }
               }
            }
        }
    }
    public class Demo6 {
        
        public static void main(String[] args) {
        
            MySync1 mySync = new MySync1();
            Thread thread1 = new Thread(mySync,"一号");
            thread1.start();
            Thread thread2 = new Thread(mySync,"二号");
            thread2.start();
            Thread thread3 = new Thread(mySync,"三号");
            thread3.start();
        }
    }

![在这里插入图片描述][9be9f47553ba47c4a050b0f2d6368ccd.png]  
至此总算和我们预期的结果一致了。那么这是什么原理呢？  
其实**synchronized**就是给代码加锁。当使用这个关键字，修饰方法的时候，这个方法就会被锁保护。

> 原理：三个线程同时抢占资源，但代码块被加了锁。只允许一个线程进入。当一个线程执行时，另外的线程等待，执行完毕以后。三个线程再开始抢占资源，这样就保证了数据的同步。

#### 守护线程和非守护线程 ####

**守护线程**

> 守护线程是用来守护非守护线程的

**非守护线程**

> 即是普通的线程

二者之间的联系为，当非守护线程一旦执行结束，那么不管守护线程有没有执行完毕，都会自动消亡。举个常见的例子。我们在电脑上登录QQ的时候，如果我们选择退出QQ，那么所有已经打开的聊天窗口都会被关闭。QQ的主界面就是非守护线程，所有打开的聊天窗口就是守护线程。  
注意：

*  一个应用程序中必须至少一个非守护线程
 *  非守护线程一旦结束，守护线程就会自动消亡
 *  main 主函数是非守护线程
 *  真实开发的时候：  
    后台记录操作日志，监控内存，垃圾回收等 都可以使用守护线程

下面看一个例子：

class MyThread1 implements  Runnable{
        
        @Override
        public void run() {
        
            System.out.println("软件更新中");
            for (int i = 0; i <= 100; i++) {
        
                System.out.println("下载资源数...."+i+"/100");
            }
        }
    }
    public class Demo1 {
        
        public static void main(String[] args) {
        
            for (int i = 0; i < 20; i++) {
        
                System.out.println("主线程正在执行"+i);
            }
            Thread thread = new Thread(new MyThread1());
            //标记为守护线程，必须在线程执行之前
            thread.setDaemon(true);
            thread.start();
        }
    }

执行结果：  
![在这里插入图片描述][33325ae10e4b45ceb19b97a3c57076ae.png]  
可以看到，当main函数中的循环走完，即使run方法的循环才刚刚执行了4次，但却直接停止执行了。这就是守护线程和非守护线程的直接表现。

### 线程死锁 ###

什么是死锁？

> 死锁是指两个或两个以上的线程在执行过程中，由于竞争资源或者由于彼此通信而造成的一种阻塞的现象，若无外力作用，它们都将无法推进下去。此时称系统处于死锁状态或系统产生了死锁，这些永远在互相等待的进程称为死锁线程。死锁是一种状态，当两个线程互相持有对方的资源的时候，却又不主动释放这个资源的时候。会导致死锁。这两个线程就会僵持住。代码就无法继续执行。

定义看上去可能并不是那么好理解，举个简单的生活场景来解释这个问题。  
我们都知道，现在各大城市的疫情防控政策都十分的完善。那么进出小区门口的时候一般都是需要扫码才能进入。注意我们的条件（一切都是在理想化的假设前提下）：

*  绿码才能进入小区的大门
 *  可是扫码的机器坏掉了，无论是谁，都扫出来的是红码
 *  根据规定，红码不允许进入小区

由于机器都是特制的，只有找专业的工作人员来维修。但是就出现了以下的问题：

*  工作人员也是外来人员，需要绿码才能被放行
 *  但是机器坏了，只能扫出来红码
 *  所以工作人员进不来
 *  所以机器也修不好

这就是一个经典的死锁问题，因为工作人员需要去维修机器，必须要进去小区。但是扫不出来绿码，不被允许进入。机器必须要修好才能扫出来绿码，但是工作人员进不来，无法进行维修。这样就进入了一个死循环。机器和维修人员都在等待对方释放自己需要的资源，又同时持有对方拥有的资源，都需要对方先释放持有的资源才能继续进行下一步。但是双方又因为只有得到对方持有的资源才能释放自己持有的资源，这样就陷入了永远的等待。这就是死锁。  
**特别注意：**  
**开发中禁止使用死锁**  
下边看一下一个简单的死锁代码：

class DeadLock implements Runnable{
        
        private boolean flag;//标记属性
        private Object obj1;//
        private Object obj2;
        //有参构造
    
    
        public DeadLock(boolean flag, Object obj1, Object obj2) {
        
            this.flag = flag;
            this.obj1 = obj1;
            this.obj2 = obj2;
        }
        @Override
        public void run() {
        
            if(flag){
        
                String name =  Thread.currentThread().getName();
                synchronized (obj1){
        
                    System.out.println(name+"拿到锁1");
    
                    System.out.println("等待锁2的释放");
                    synchronized (obj2){
        
                        System.out.println(name+"-》拿到锁2");
                    }
                }
            }
            if (!flag){
        
                String name =  Thread.currentThread().getName();
                synchronized (obj2){
        
                    System.out.println(name+"拿到锁2");
    
                    System.out.println("等待锁1的释放");
                    synchronized (obj1){
        
                        System.out.println(name+"-》拿到锁1");
                    }
                }
            }
        }
    }
    public class Demo3 {
        
        public static void main(String[] args) {
        
            Object  o1 = new Object();
            Object  o2 = new Object();
            //第一个线程  flag 是true
            DeadLock deadLock = new DeadLock(true, o1, o2);
            new Thread(deadLock, "线程1").start();
            //第二个线程 flag  是flase
            DeadLock deadLock1 = new DeadLock(false, o1, o2);
            new Thread(deadLock1, "线程2").start();
        }
    }

执行结果：  
![在这里插入图片描述][20095a77a0264940b769eca2b9989540.png]  
可以看到，代码一直僵持在这里，无法执行。

#### 线程的生命周期 ####

一个线程从创建，到执行结束，一共有五个部分组成

> **1. 新建：当一个Thread类或其子类的对象被声明并创建时。新生的线程对象属于新建状态。**  
> **2. 就绪（可运行状态）：处于新建状态的线程执行start()方法后，进入线程队列等待CPU时间片，该状态具备了运行的状态，只是没有分配到CPU资源。**  
> **3. 运行：就绪的线程分配到CPU资源便进入运行状态，run()方法定义了线程的操作。**  
> **4. 阻塞：在某种特殊情况下，被人为挂起或执行输入输出操作时，让出CPU并临时终止自己的的执行，进入阻塞状态。**  
> **5. 消亡：当线程执行完自己的操作或提前被强制性的终止或出现异常导致结束，会进入死亡状态。**  
> ![在这里插入图片描述][efd2e377379b4a3a8547a1415daa903f.png]

#### 线程的等待与唤醒 ####

Object类下边有这样三个和线程有关的方法

1.  wait():让线程进入阻塞状态。除非被唤醒，否则不会继续执行。
2.  notify()唤醒正在等待对象监视器的单个线程。
3.  notifyAll()唤醒正在等待对象监视器的所有线程。

注意：

> 线程的等待和唤醒通常都是搭配使用的，至少两个线程，其中一个线程中使用对象.wait() 那么这个线程就会阻塞，代码不会往下执行了。如何想让这个线程往下执行呢？再开另外一个线程，使用对象.notify()去唤醒另外那个等待线程。两个线程使用的是同一个对象。

下边看代码：

import java.text.SimpleDateFormat;
    import java.util.Date;
    
    class Message{
        
        private String msg;
    
        public Message(String msg) {
        
            this.msg = msg;
        }
    
        public String getMsg() {
        
            return msg;
        }
    
        public void setMsg(String msg) {
        
            this.msg = msg;
        }
    
        @Override
        public String toString() {
        
            return "Message{" +
                    "msg='" + msg + '\'' +
                    '}';
        }
    }
    class NotifyThread implements  Runnable{
        
        private Message message;
    
        public NotifyThread(Message message) {
        
            this.message = message;
        }
    
        @Override
        public void run() {
        
            try {
        
                Thread.sleep(5000);
                //等待5秒，让等待线程先执行等待
            } catch (InterruptedException e) {
        
                e.printStackTrace();
            }
            String name = Thread.currentThread().getName();
            Date date = new Date(System.currentTimeMillis());
            SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
            System.out.println(name+"开始唤醒等待线程:"+ sdf.format(date));
            synchronized (message){
        
                message.setMsg("修改之后的message");
                //message.notify();
                message.notifyAll();
    
            }
        }
    }
    class WaitThread implements  Runnable{
        
        private Message message;
    
        public WaitThread(Message message) {
        
            this.message = message;
        }
        @Override
        public void run() {
        
            String name = Thread.currentThread().getName();
            Date date1 = new Date(System.currentTimeMillis());
            SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
            System.out.println(name+"等待唤醒时间："+sdf.format(date1));
            synchronized (message){
        
                try {
        
                    message.wait();
                } catch (InterruptedException e) {
        
                    e.printStackTrace();
                }
                Date date2 = new Date(System.currentTimeMillis());
                System.out.println(name+ "被唤醒的时间："+sdf.format(date2));
            }
        }
    }
    public class Demo2 {
        
        public static void main(String[] args) {
        
            Message message = new Message("我是信息");
            WaitThread waitThread1 = new WaitThread(message);
            WaitThread waitThread2 = new WaitThread(message);
            WaitThread waitThread3 = new WaitThread(message);
            NotifyThread notifyThread = new NotifyThread(message);
            new Thread(waitThread1,"等待线程1").start();
            new Thread(waitThread2,"等待线程2").start();
            new Thread(waitThread3,"等待线程3").start();
            new Thread(notifyThread,"唤醒线程").start();
    
        }
    }

执行结果：  
![在这里插入图片描述][fc6c8d7e0add430d8bf38a5c5f567d15.png]

#### 生产者消费者模式 ####

> 生产者与消费者模式就是一个多线程并发协作的模式，在这个模式中，一部分线程被用于去生产数据，另一部分线程去处理数据，于是便有了所谓的生产者与消费者。

要用Java实现这个模式，我们可以借助线程的wait()，和notify()，方法。  
案例：  
假设，现在有一名农民伯伯要去买拖拉机。现在制造商为了不让货卖不出去砸在自己手里，于是他就每次只生产一台，只有上一台卖掉了，才会生产下一台。农民伯伯是每次只卖一台拖拉机，只要制造商生产出一台，他就会买一台。下面看代码：

//两个线程要通信，需要一个中间对象
    class Goods{
        
        private String name;
        private double price;
        private boolean isProduct;//是否需要生产ture，false
    
        public Goods(String name, double price, boolean isProduct) {
        
            this.name = name;
            this.price = price;
            this.isProduct = isProduct;
        }
    
        public String getName() {
        
            return name;
        }
    
        public void setName(String name) {
        
            this.name = name;
        }
    
        public double getPrice() {
        
            return price;
        }
    
        public void setPrice(double price) {
        
            this.price = price;
        }
    
        public boolean isProduct() {
        
            return isProduct;
        }
    
        public void setProduct(boolean product) {
        
            isProduct = product;
        }
    
        @Override
        public String toString() {
        
            return "Goods{" +
                    "name='" + name + '\'' +
                    ", price=" + price +
                    ", isProduct=" + isProduct +
                    '}';
        }
    }
    //厂家
    class Producer implements Runnable{
        
        private Goods goods;
    
        public Producer(Goods goods) {
        
            this.goods = goods;
        }
    
        @Override
        public void run() {
        //消费者消费了，就必须要生产
            int order = 0;
            while (true){
        
                synchronized (goods){
        
                    try {
        
                        Thread.sleep(3000);
                    } catch (InterruptedException e) {
        
                        e.printStackTrace();
                    }
                    if(goods.isProduct()){
        //需要生产
                        //造车
                        if (order % 2 == 0){
        
                            goods.setName("奔马拖拉机");
                            goods.setPrice(200000);
                        }else {
        
                            goods.setName("泰山拖斗");
                            goods.setPrice(10000);
                        }
                        goods.setProduct(false);//设置标记为不需要生产
                        System.out.println("制造商制造了："+goods.getName()+"，价格："+goods.getPrice());
                        order++;
                        //唤醒消费者线程
                        goods.notify();
                    }else{
        //不需要生产，工厂休息
                        try {
        
                            goods.wait();
                        } catch (InterruptedException e) {
        
                            e.printStackTrace();
                        }
                    }
                }
            }
        }
    }
    //顾客
    class Customer implements Runnable{
        
        private Goods goods;//通过商品联系生产者和消费者
    
        public Customer(Goods goods) {
        
            this.goods = goods;
        }
    
        @Override
        public void run() {
        
            while (true){
        //购买车
                synchronized (goods){
        
                    try {
        
                        Thread.sleep(3000);
                    } catch (InterruptedException e) {
        
                        e.printStackTrace();
                    }
                    if (!goods.isProduct()){
        //不需生产
                       //买
                        System.out.println("农民伯伯买了："+goods.getName());
                        goods.setProduct(true);
                        goods.notify();//唤醒生产者的等待线程
                    }else {
        
                        //买不到，自己需要等待
                        try {
        
                           goods.wait();
                        } catch (InterruptedException e) {
        
                            e.printStackTrace();
                        }
                    }
                }
            }
        }
    }
    public class Demo6 {
        
        public static void main(String[] args) {
        
            Goods goods = new Goods("奔驰大G",100000,false);
            Customer customer = new Customer(goods);
            new Thread(customer,"消费者").start();
            Producer producer = new Producer(goods);
            new Thread(producer,"制造商").start();
        }
    }

执行结果：  
![在这里插入图片描述][ca1dff4e4b844cffb05547fd8ccc6be1.png]

案例中，只要拖拉机卖出去，就会唤醒制造商线程，制造车辆。而此时农民伯伯线程是处于等待状态。等制造商制造了一台车，就会让自己的线程状态设为等待，而将农民伯伯的线程唤醒让他前来买车。。制造商充当生产者，农民伯伯充当消费者。就这样形成一个生产者消费者模式。

本篇内容至此结束，关于线程池，由于实力不允许，这里就不再过多介绍。。。。。

[0c31319ad38f4d65b282632810a8a8a9.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/08/8c5c099264c947ceb846a19bb3d11a13.png
[1ff0cf767cb6401e8d9a5b1d8d1e2a31.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/08/20b584e1d6da40798e144fa72245ceff.png
[019d61509f7f41b8832767baeaa81be1.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/08/1b5726f7f2814cc980fad4cc1730b685.png
[9be9f47553ba47c4a050b0f2d6368ccd.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/08/53923aa459b64fa0865ae5145d0df3e0.png
[33325ae10e4b45ceb19b97a3c57076ae.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/08/061158a2854c45e6b6dedd7ec52b84c2.png
[20095a77a0264940b769eca2b9989540.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/08/a51e53b22bbd4b548431fbb3a2c57161.png
[efd2e377379b4a3a8547a1415daa903f.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/08/1f41fbf1ff704ef6966328c0027a43f9.png
[fc6c8d7e0add430d8bf38a5c5f567d15.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/08/4299f4af1b904a62b1607775debec22a.png
[ca1dff4e4b844cffb05547fd8ccc6be1.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/08/559e94f646c84239b3e5b648cb1da46e.png