Java多线程基本概念详解（下）

落日映苍穹つ 2023-02-18 05:26 3阅读 0赞

### 目录 ###

*   *   *  一.线程同步，并发，并行，锁的概念
         *  二.三大不安全案例以及用锁解决
         *   *  ①买票问题
             *  ②银行取钱
             *  ③线程不安全集合
         *  三.死锁
         *  四.Lock锁
         *  五.生产者与消费者问题
         *  六.线程池（Executor）

### 一.线程同步，并发，并行，锁的概念 ###

`线程同步`: 多个线程操作同一个资源。

> 多个线程访问同一个对象时，有的线程可能还想修改这些对象，这个时候就需要线程同步，线程同步就是一种等待的机制，多个需要访问此对象的线程就需要进入对象的线程池中形成队列，等当前线程访问完成过后下一个线程才能进行访问此对象

`并发`: 同一个对象被多个线程同时操作（两件或者多件事在同一时间段同时发生）

>  *  上万人抢100张票
>  *  两个银行同时取同一账户的钱

`并行`: 两件或多件事在同一时刻同时发生

`锁`: 同一线程会有很多线程，这些线程共享这一块资源，但是当这些线程访问资源的时候就可能会 出现访问冲突的问题，从而降低了数据的准确性，就引出锁`synchronized`的概念,当一个线程上锁之后其他线程必须等待，访问完之后，释放锁即可，但是也会出现一些性能降低的问题。

### 二.三大不安全案例以及用锁解决 ###

**什么是线程安全？**  
如果多个线程同时运行同一个实现Runable接口的类，程序每次运行的结果和单线程运行的结果是一样的，并且其他变量的值也是与预期的一样，就是线程安全。

#### ①买票问题 ####

/** * @author jektong * @Date 2020/6/16-10:52 */
    public class BuyTicket implements Runnable { 
        //票数
        private  int tickets = 10;
        //设置外部停止方式
        boolean flag = true;
        @Override
        public void run() { 
            while(flag){ 
                buy();
            }
        }
        private void buy(){ 
            //是否有票？
            if(tickets <= 0){ 
                flag = false;
                return;
            }
            //加延时
            try { 
                Thread.sleep(1000);
            } catch (InterruptedException e) { 
                e.printStackTrace();
            }
            //买票开始
            System.out.println(Thread.currentThread().getName() + "拿到第" + tickets-- +"张票");
        }
        public static void main(String[] args) { 
            BuyTicket buyTicket = new BuyTicket();
            Thread thread1 = new Thread(buyTicket,"小明");
            Thread thread2 = new Thread(buyTicket, "小红");
            Thread thread3 = new Thread(buyTicket, "黄牛");
            thread1.start();
            thread2.start();
            thread3.start();
        }
    }

这段代码实际上是不安全的，因为没有让这三个人去排队买票就会出现问题：  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQxODU3OTU1_size_16_color_FFFFFF_t_70]  
很显然这是错误的，只要将buy()这个方法加入锁`synchronized`就可以避免这个问题了，就是同步方法的方式

`private synchronized void buy(){...}`

#### ②银行取钱 ####

/** * @author jektong * @Date 2020/6/16-13:20 */
    //模拟银行取钱，两人同时取一个人的账户
    public class ThreadBank{ 
        public static void main(String[] args) { 
            Account account = new Account(100, "结婚基金");
            DrawMoney threadBank1 = new DrawMoney(account,50, "你");
            DrawMoney threadBank2 = new DrawMoney(account,70, "女朋友");
            threadBank1.start();
            threadBank2.start();
        }
    }
    class DrawMoney extends Thread{ 
        //账户
        Account account;
        //取钱
        int drawMoney;
        //现在手里有多少钱
        int nowMoney;
        public DrawMoney(Account account, int drawMoney, String name){ 
            super(name);
            this.account = account;
            this.drawMoney = drawMoney;
        }
        //取钱
        @Override
        public void run() { 
            synchronized (account){ 
            //判断有没有钱
            if(account.money - drawMoney < 0){ 
                System.out.println(Thread.currentThread().getName() + "钱不够，取不了");
                return;
            }
            try { 
                Thread.sleep(1000);
            } catch (InterruptedException e) { 
                e.printStackTrace();
            }
            //卡内余额
            account.money = account.money - drawMoney;
            System.out.println(account.name + "余额为：" + account.money);
            //手里的钱
            nowMoney = nowMoney + drawMoney;
            System.out.println(this.getName() + "手里的钱：" + nowMoney);
            }
        }
    }
    class Account{ 
        //账户的钱
         int money;
        //卡号
         String name;
        public Account(int money, String name) { 
            this.money = money;
            this.name = name;
        }
    }

对于银行取钱使用同步方法的方式就不会起作用了，同步run方法不会发生作用，需要使用同步块的方式将账户锁住就OK了，如下图：  
![在这里插入图片描述][20200616141924278.png]

#### ③线程不安全集合 ####

/** * @author jektong * @Date 2020/6/16-14:35 */
    public class ThreadList { 
        public static void main(String[] args) { 
            List<String> list = new ArrayList();
            for (int i = 0; i < 10000 ; i++) { 
               new Thread(() ->{ 
                   list.add(Thread.currentThread().getName());
               }).start();
            }
            try { 
                Thread.sleep(3000);
            } catch (InterruptedException e) { 
                e.printStackTrace();
            }
            System.out.println(list.size());
        }
    }

给线程休眠后发现输出的size只有9999（如下图）而不是10000，体现出ArrayList线程是不安全的，解决方法就是使用同步块的方式将此代码块锁住`synchronized (list){list.add(Thread.currentThread().getName());}`就可以输出10000了  
![在这里插入图片描述][20200616144334785.png]

### 三.死锁 ###

某个同步块同时拥有“两个或者多个以上对象的锁”就可能发生死锁的问题，产生死锁的四个必要条件，只要解决以下任意一个或者多个就可以避免死锁的发生：

*  互斥条件：一个资源只能被一个线程去使用
 *  请求与保持条件：一个进程因请求资源而阻塞时，对自己获得的资源保持不放
 *  不剥夺条件：进程已获得资源，在未使用之前，不能强行剥夺
 *  循坏等待条件：若干进程之间形成一种头尾相接的循坏等待资源的关系

两个姑娘用一个口红和一面镜子，一把锁中不能在用另一把锁，不然会导致死锁，可以将锁独立出来即可

/** * @author jektong * @Date 2020/6/16-16:16 */
    public class ThreadLock { 
        public static void main(String[] args) { 
            MakeUp m1 = new MakeUp(0,"灰姑娘");
            MakeUp m2 = new MakeUp(1,"白雪公主");
            Thread thread1 = new Thread(m1);
            Thread thread2 = new Thread(m2);
            thread1.start();
            thread2.start();
        }
    }
    //口红
    class Lipstick{ 
    }
    //镜子
    class Mirror{ 
    }
    
    class MakeUp implements Runnable{ 
        //static保证的资源只有一份
        static Lipstick lipstick = new Lipstick();
        static Mirror mirror = new Mirror();
    
        int choice;
        String girlName;
    
        MakeUp(int choice, String girlName){ 
            this.choice = choice;
            this.girlName = girlName;
        }
        private void makeup() throws InterruptedException { 
            if(choice == 0){ 
                synchronized (lipstick){ 
                    System.out.println(this.girlName + "获得口红的锁");
                    Thread.sleep(1000);
                }
                synchronized (mirror){ 
                    System.out.println(this.girlName + "获得镜子的锁");
                }
            }else{ 
                synchronized (mirror){ 
                    System.out.println(this.girlName + "获得镜子的锁");
                    Thread.sleep(2000);
                }
                synchronized (lipstick){ 
                    System.out.println(this.girlName + "获得口红的锁");
                }
            }
        }
        @Override
        public void run() { 
            try { 
                makeup();
            } catch (InterruptedException e) { 
                e.printStackTrace();
            }
        }
    }

运行结果如下：  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQxODU3OTU1_size_16_color_FFFFFF_t_70 1]

### 四.Lock锁 ###

Lock锁与synchronized锁基本原理是一样的，不同的是lock必须使用手动去开启和关闭，它是显示的锁，Lock只能锁代码块，不可锁方法。Lock主要使用 `ReentrantLock`这个类创建对象

用Lock锁来解决前面购票问题：

/** * @author jektong * @Date 2020/6/16-10:52 */
    public class BuyTicket implements Runnable { 
    
        private final ReentrantLock lock = new ReentrantLock();
        //票数
        private  int tickets = 10;
        //设置外部停止方式
        boolean flag = true;
    
        @Override
        public void run() { 
            lock.lock();//加锁
            while(flag){ 
                buy();
            }
            lock.unlock();//解锁
        }
        private  void buy(){ 
            //是否有票？
            if(tickets <= 0){ 
                flag = false;
                return;
            }
            //加延时
            try { 
                Thread.sleep(1000);
                //买票开始
                System.out.println(Thread.currentThread().getName() 
                + "拿到第" + tickets-- +"张票");
            } catch (InterruptedException e) { 
                e.printStackTrace();
            }
        }
        public static void main(String[] args) { 
            BuyTicket buyTicket = new BuyTicket();
            Thread thread1 = new Thread(buyTicket,"小明");
            Thread thread2 = new Thread(buyTicket, "小红");
            Thread thread3 = new Thread(buyTicket, "黄牛");
            thread1.start();
            thread2.start();
            thread3.start();
        }
    }

### 五.生产者与消费者问题 ###

应用场景：

*  仓库中只能放一件商品，生产者将生产出来的商品放入仓库，消费者从仓库中取走商品消费
 *  若仓库无商品，生产者放入商品进仓库，否则停止生产并等待，指导商品被消费者取走
 *  若仓库有商品，消费者拿走商品消费，否则消费者停止消费并等待，知道仓库中有商品

分析：这是一个线程同步问题，两者共享一个资源，并且两者相互依赖，互为条件。在此问题中，多个线程共享一块资源，但是要对资源进行不同的任务操作，仅仅使用synchronized是不够的，虽然可以实现同步，但是不能解决线程之间的通信问题。

Java提供了几个方法：

`wait()`:线程一直等待，指导其他线程的通知，与sleep不同的是，会释放锁

`wait(long timeout）`指定等待的毫秒数

`notify()`唤醒一个处于等待的线程

`notifyAll()`唤醒同一个对象上所有调用wait()方法的线程，优先级别高的线程优先调度

**解决方式1：管程法：加入一个缓冲区，生产者将数据放入缓冲区，消费者将数据从缓冲区拿出**

/** * @author jektong * @Date 2020/6/16-18:24 */
    //管程法解决生产者与消费者模型
    public class ThreadPC { 
        public static void main(String[] args) { 
            SynContainer synContainer = new SynContainer();
            new Product(synContainer).start();
            new Consumer(synContainer).start();
        }
    }
    //生产者
    class Product extends Thread{ 
        SynContainer container;
        public Product(SynContainer container){ 
            this.container = container;
        }
        //生产
        @Override
        public void run(){ 
            for (int i = 1; i < 100 ; i++) { 
                container.push(new Chicken(i));
                System.out.println("生产了" + i + "只鸡");
            }
        }
    }
    //消费者
    class Consumer extends Thread{ 
        SynContainer container;
        public Consumer(SynContainer container){ 
            this.container = container;
        }
        @Override
        public void run(){ 
            for (int i = 1; i < 100 ; i++) { 
                System.out.println("消费了" + container.pop().id + "只鸡");
            }
        }
    }
    //产品鸡
    class Chicken{ 
        int id;
        public Chicken(int id) { 
            this.id = id;
        }
    }
    //缓冲区
    class SynContainer{ 
        //需要容器大小
        Chicken chickens[] = new Chicken[10];
        int count = 0;
        //生产者放入产品
        public synchronized void push(Chicken chicken){ 
            //如果容器满了则需通知消费者消费
            if(count == chickens.length){ 
                try { 
                    this.wait();
                } catch (InterruptedException e) { 
                    e.printStackTrace();
                }
            }
            //如果没有满，丢鸡进去
            chickens[count] = chicken;
            count++;
            //通知消费者消费
            this.notifyAll();
        }
        //消费者消费
        public synchronized Chicken pop(){ 
            //判断是否消费
            if(count == 0){ 
                //等待生产者生产，消费者等待
                try { 
                    this.wait();
                } catch (InterruptedException e) { 
                    e.printStackTrace();
                }
            }
            //消费
            count--;
            Chicken chicken = chickens[count];
            //鸡吃完了，通知生产者生产
            this.notifyAll();
            return chicken;
        }
    }

**解决方式2：信号灯法：采用一个标志位来指定线程的等待和通知其他线程执行**

/** * @author jektong * @Date 2020/6/16-21:19 */
    //测试生产者消费者问题：信号灯法，标志位解决
    public class ThreadPC02  { 
        public static void main(String[] args) { 
            Tv t1 = new Tv();
            new Player(t1).start();
            new Watcher(t1).start();
        }
    }
    //生产者--->演员
    class Player extends Thread{ 
        Tv tv;
        public Player(Tv tv){ 
            this.tv = tv;
        }
        @Override
        public void run(){ 
            for (int i = 0; i < 20 ; i++) { 
                if(i%2==0){ 
                    this.tv.play("快手");
                }else { 
                    this.tv.play(("抖音"));
                }
            }
        }
    }
    //消费者--->观众
    class Watcher extends Thread{ 
        Tv tv;
        public Watcher(Tv tv){ 
            this.tv = tv;
        }
    
        @Override
        public void run(){ 
            for (int i = 0; i < 20 ; i++) { 
                tv.watch();
            }
        }
    }
    //产品---> 节目
    class Tv{ 
        //演员表演，观众等待
        //观众观看，演员等待
        String voice;//表演的节目
        boolean flag = true;//标志位
        //表演
        public synchronized void play(String voice){ 
            if(!flag){ 
                try { 
                    this.wait();
                } catch (InterruptedException e) { 
                    e.printStackTrace();
                }
            }
            System.out.println("演员表演了：" + voice);
            //通知观众观看
            this.notifyAll();//唤醒
            this.voice = voice;
            this.flag = !this.flag;
        }
        //观看
        public synchronized void watch(){ 
            if (flag){ 
                try { 
                    this.wait();
                } catch (InterruptedException e) { 
                    e.printStackTrace();
                }
            }
            System.out.println("观看了：" + voice);
            this.notifyAll();
            this.flag = !this.flag;
        }
    }

### 六.线程池（Executor） ###

经常的创建和销毁，使用量特别大的资源，比如并发情况下的线程，对性能影响很大。提前创建好多个线程，放入线程池中，使用时直接获取，用完再放入线程池中，就可以重复利用了。

**线程池的使用**

/** * @author jektong * @Date 2020/6/17-9:02 */
    public class ThreadExecutor implements Runnable { 
        public static void main(String[] args) { 
            //获取线程池对象
            ExecutorService executorService = Executors.newFixedThreadPool(10);
            //执行
            executorService.execute(new ThreadExecutor());
            executorService.execute(new ThreadExecutor());
            executorService.execute(new ThreadExecutor());
            //关闭
            executorService.shutdown();
        }
        @Override
        public void run() { 
            for (int i = 0; i < 10 ; i++) { 
                System.out.println(Thread.currentThread().getName() + "开始" + i);
            }
        }
    }

[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQxODU3OTU1_size_16_color_FFFFFF_t_70]: https://img-blog.csdnimg.cn/20200616125533620.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQxODU3OTU1,size_16,color_FFFFFF,t_70
[20200616141924278.png]: https://img-blog.csdnimg.cn/20200616141924278.png
[20200616144334785.png]: https://img-blog.csdnimg.cn/20200616144334785.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQxODU3OTU1_size_16_color_FFFFFF_t_70 1]: https://img-blog.csdnimg.cn/20200616164515305.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQxODU3OTU1,size_16,color_FFFFFF,t_70