【Java 多线程】线程的同步互斥和线程安全

￡神魔★判官ぃ 2022-12-18 02:54 90阅读 0赞

### 文章目录 ###

*   *  线程同步
     *  三大不安全案例
     *  同步方法及同步块
     *  死锁
     *  Lock 锁
     *  生产者和消费者模式
     *  线程池

## 线程同步 ##

并发：同一个对象被多个线程同时操作

处理多线程问题时，多个线程访问同一个对象，并且某些线程还想修改这个对象，这时候我们就需要线程同步，线程同步其实就是一种等待机制，多个需要同时访问此对象的线程进入这个对象的等待池形成队列，等待前面的队列使用完毕后，下一个线程再使用

另外由于同一进程的多个线程共享地址空间，为了保证数据的在方法中被访问的正确性，在访问时加入了锁机制 synchronized ，当一个线程获得对象的排它锁，独占资源，其他线程必须等待，使用后释放锁即可，但是会存在以下问题

*  一个线程持有锁，会导致其他所有需要此锁的线程挂起
 *  在多线程竞争下，加锁，释放锁会导致比较多的上下文切换和调度延时，引起性能问题
 *  如果一个优先级高的线程等待一个优先级低的线程释放锁，会导致优先级倒置，引起性能问题

## 三大不安全案例 ##

1、线程不安全的买票案例

public class UnsafeBuyTicket { 
        public static void main(String[] args) { 
            BuyTicket station = new BuyTicket();
            new Thread(station,"A").start();
            new Thread(station,"B").start();
            new Thread(station,"H").start();
        }
    }
    
    class BuyTicket implements Runnable{ 
        private int ticket = 10;
        private boolean flag = true;
        @Override
        public void run() { 
            while(flag){ 
                try { 
                    buy();
                } catch (InterruptedException e) { 
                    e.printStackTrace();
                }
            }
        }
        private void buy() throws InterruptedException { 
            //判断是否有票
            if(ticket <= 0){ 
                flag = false;
                return;
            }
            //模拟演示
            Thread.sleep(100);
            System.out.println(Thread.currentThread().getName() + "拿到了" + ticket-- +"票");
        }
    }

2、线程不安全的取钱案例

public class unsafeBank { 
        public static void main(String[] args) { 
            Account account = new Account(100, "结婚基金");
    
            Drawing you = new Drawing(account,50,"你");
            Drawing girlfriend = new Drawing(account,100,"girlfriend");
    
            you.start();
            girlfriend.start();
        }
    }
    
    // 账号
    class Account{ 
        int money;
        String name;
    
        public Account(int money, String name) { 
            this.money = money;
            this.name = name;
        }
    }
    
    
    //银行
    class Drawing extends Thread{ 
        Account account;
        int drawing; //取了多少钱
        int nowMoney; //现在余额
        public Drawing(Account account,int drawing,String name){ 
            super(name);
            this.account = account;
            this.drawing = drawing;
        }
        //取钱
    
        @Override
        public void run() { 
            //判断有没有钱
            if(account.money-drawing < 0){ 
                System.out.println(Thread.currentThread().getName()+"钱不够了");
                return;
            }
            try { 
                Thread.sleep(1000);
            } catch (InterruptedException e) { 
                e.printStackTrace();
            }
            account.money -=drawing;
            nowMoney += drawing;
    
            System.out.println(account.name + "余额为" + account.money);
            System.out.println(this.getName() + "手里的钱为：" + nowMoney);
        }
    }

3、线程不安全的集合

public class unsafeList { 
        public static void main(String[] args) { 
            List<String>list = new ArrayList<String>();
            for (int i = 0; i < 10000; i++) { 
                new Thread(()->{ 
                	// 可能会有多个线程添加到同一个位置，所以被覆盖掉了
                    list.add(Thread.currentThread().getName());
                }).start();
            }
            // 这里最终的结果应该要等于10000，然而实际要小于10000 
            System.out.println(list.size());
        }
    }

## 同步方法及同步块 ##

Java 针对方法提出一套机制，synchronized 关键字有两种用法，synchronized 方法和 synchronized 块

每个对象都有一把锁，每个 synchronized 方法都必须获得调用该方法的对象才能执行，否则线程会阻塞，方法一旦执行就会独占锁，直到该方法返回才释放锁

同步方法的线程安全抢票案例

public class UnsafeBuyTicket { 
        public static void main(String[] args) { 
            BuyTicket station = new BuyTicket();
            new Thread(station,"A").start();
            new Thread(station,"B").start();
            new Thread(station,"H").start();
        }
    }
    
    class BuyTicket implements Runnable{ 
        private int ticket = 10;
        private boolean flag = true;
    
        @Override
        public void run() { 
            while(flag){ 
                try { 
                    buy();
                } catch (InterruptedException e) { 
                    e.printStackTrace();
                }
            }
        }
        // 同步方法,锁的是 this
        private synchronized void buy() throws InterruptedException { 
            //判断是否有票
            if(ticket <= 0){ 
                flag = false;
                return;
            }
            //模拟演示
            Thread.sleep(100);
            System.out.println(Thread.currentThread().getName() + "拿到了" + ticket-- +"票");
        }
    }

同步块线程安全的银行取钱案例

synchronized (Obj)\{\}

Obj 为同步监视器，增删改查的对象

public class unsafeBank { 
        public static void main(String[] args) { 
            Account account = new Account(100, "结婚基金");
    
            Drawing you = new Drawing(account,50,"你");
            Drawing girlfriend = new Drawing(account,100,"girlfriend");
    
            you.start();
            girlfriend.start();
        }
    }
    
    // 账号
    class Account{ 
        int money;
        String name;
    
        public Account(int money, String name) { 
            this.money = money;
            this.name = name;
        }
    }
    
    
    //银行
    class Drawing extends Thread{ 
        Account account;
        int drawing; //取了多少钱
        int nowMoney; //现在余额
        public Drawing(Account account,int drawing,String name){ 
            super(name);
            this.account = account;
            this.drawing = drawing;
        }
        //取钱
    
        @Override
        public void run() { 
            //同步块锁的是变化的量（需要增删改的对象）
            synchronized (account) { 
                //判断有没有钱
                if (account.money - drawing < 0) { 
                    System.out.println(Thread.currentThread().getName() + "钱不够了");
                    return;
                }
                try { 
                    Thread.sleep(1000);
                } catch (InterruptedException e) { 
                    e.printStackTrace();
                }
                account.money -= drawing;
                nowMoney += drawing;
    
                System.out.println(account.name + "余额为" + account.money);
                System.out.println(this.getName() + "手里的钱为：" + nowMoney);
            }
        }
    }

线程安全的容器 ArrayList

package syn;
    
    import java.util.ArrayList;
    import java.util.List;
    
    /** * @Title: * @Package * @Description: * @author: maze * @date 2020/10/25上午 2:07 */
    public class unsafeList { 
        public static void main(String[] args) { 
            List<String>list = new ArrayList<String>();
    
            for (int i = 0; i < 10000; i++) { 
                new Thread(()->{ 
                    synchronized (list) { 
                        list.add(Thread.currentThread().getName());
                    }
                }).start();
            }
            // 这里是让所有线程一起等待3秒
            try { 
                Thread.sleep(3000);
            } catch (InterruptedException e) { 
                e.printStackTrace();
            }
            System.out.println(list.size());
        }
    }

补充：JUC 并发编程中有一个 concurrent 包下的线程安全的 ArrayList

案例

public class TestJUC { 
        public static void main(String[] args) { 
            CopyOnWriteArrayList<String> list = new CopyOnWriteArrayList<>();
            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());
        }
    }

## 死锁 ##

多个线程互相抱着对方需要的资源，形成僵持

死锁案例

public class DeadLock { 
        public static void main(String[] args) { 
            Makeup g1 = new Makeup(0,"灰姑娘");
            Makeup g2 = new Makeup(1,"白雪公主");
    
            g1.start();
            g2.start();
        }
    }
    //口红
    class Lipstick{ 
    
    }
    //镜子
    class Mirror{ 
    
    }
    
    class Makeup extends Thread{ 
        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;
        }
    
    
        @Override
        public void run() { 
            //化妆
            try { 
                makeup();
            } catch (InterruptedException e) { 
                e.printStackTrace();
            }
        }
        // 互相持有对方的锁
        private void makeup() throws InterruptedException { 
            if(choice == 0){ 
                synchronized (lipstick){ 
                    System.out.println(this.girlName +"获得口红的锁");
                    Thread.sleep(2000);
                    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 + "获得口红的锁");
                    }
                }
            }
        }
    }

解决办法：不要让对象获取对方的锁就行了

public class DeadLock { 
        public static void main(String[] args) { 
            Makeup g1 = new Makeup(0,"灰姑娘");
            Makeup g2 = new Makeup(1,"白雪公主");
    
            g1.start();
            g2.start();
        }
    }
    //口红
    class Lipstick{ 
    }
    //镜子
    class Mirror{ 
    }
    
    class Makeup extends Thread{ 
        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;
        }
    
    
        @Override
        public void run() { 
            //化妆
            try { 
                makeup();
            } catch (InterruptedException e) { 
                e.printStackTrace();
            }
        }
        // 互相持有对方的锁
        private void makeup() throws InterruptedException { 
            if(choice == 0){ 
                synchronized (lipstick){ 
                    System.out.println(this.girlName +"获得口红的锁");
                    Thread.sleep(2000);
                }
                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 + "获得口红的锁");
                }
            }
        }
    }

死锁的四个必要条件

*  互斥条件
 *  请求与保持条件
 *  不可剥夺条件
 *  环路等待条件

## Lock 锁 ##

从 JDK 5.0 Java 提供了更强大的线程同步机制，通过显示定义同步锁来实现同步，同步锁使用 Lock 对象充当

ReentrantLock 类实现了 Lock ，它拥有与 synchronized 相同的并发性和内存语义，在实现线程安全的控制中，比较常用的是 ReentrantLock ，可以显示加锁和释放

public class TestLock { 
        public static void main(String[] args) { 
            TestLock2 lock2 = new TestLock2();
    
            new Thread(lock2,"A").start();
            new Thread(lock2,"B").start();
            new Thread(lock2,"C").start();
        }
    }
    class TestLock2 implements Runnable{ 
        int ticketNum = 10;
        // 定义 lock 锁
        private ReentrantLock reentrantLock = new ReentrantLock();
    
        @Override
        public void run() { 
            while (true){ 
                reentrantLock.lock();
                try { 
                    if(ticketNum >0){ 
                        try { 
                            Thread.sleep(1000);
                        } catch (InterruptedException e) { 
                            e.printStackTrace();
                        }
    
                        System.out.println(ticketNum--);
                    }
                    else{ 
                        break;
                    }
                }
                finally { 
                   reentrantLock.unlock();
                }
           }
        }
    }

**synchronized 和 Lock 的区别**

*  Lock 是显示的锁，手动开启和关闭，synchronized 是隐式锁，出了作用域自动释放
 *  Lock 只能代码块锁，synchronized 有代码锁和方法锁
 *  使用 Lock 锁，JVM 将花费更少的时间调度线程，性能更好，并且具有更好的扩展性(提供子类)
 *  优先使用顺序：Lock > 同步代码块(已经进入了方法体，分配了相应资源)> 同步方法(在方法体之外)

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

线程的协作

Java 提供了几个方法解决线程之间的通信方法

<table> 
 <thead> 
  <tr> 
   <th>方法名</th> 
   <th>作用</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td>wait()</td> 
   <td>表示线程一直等待，直到其他线程通知</td> 
  </tr> 
  <tr> 
   <td>wait(long timeout)</td> 
   <td>指定等待的毫秒数</td> 
  </tr> 
  <tr> 
   <td>notify()</td> 
   <td>唤醒一个处于等待的线程</td> 
  </tr> 
  <tr> 
   <td>notifyAll()</td> 
   <td>唤醒同一个对象上所有调用 wait 方法的线程，优先级高的线程优先被调度</td> 
  </tr> 
 </tbody> 
</table>

> 注意：这些都是Object 类的方法，都只能在同步方法或者同步代码块中使用，否则会抛出异常

1、管程法

package syn;
    
    /** * @Title: * @Package * @Description: * @author: maze * @date 2020/10/25下午 21:16 */
    public class TestPc { 
        public static void main(String[] args) { 
            SynContainer container = new SynContainer();
    
            new Productor(container).start();
            new Consumer(container).start();
        }
    }
    //生产者
    class Productor extends Thread{ 
        SynContainer container;
        public Productor(SynContainer container) { 
            this.container = container;
        }
    
        @Override
        public void run() { 
            for (int i = 0; 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 = 0; 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];
        //容器计数器
        private 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+=1;
    
            //通知消费者
            this.notifyAll();
        }
    
        //消费者消费产品
        public synchronized Chicken pop(){ 
            if(count ==0){ 
                //等待生产者
                try { 
                    this.wait();
                } catch (InterruptedException e) { 
                    e.printStackTrace();
                }
            }
            count -=1;
            Chicken chicken= chickens[count];
            // 通知生产者,进行生产
            this.notifyAll();
            return chicken;
        }
    }

2、信号灯法，标志位解决

public class TestPc { 
        public static void main(String[] args) { 
            TV tv = new TV();
    
            new Player(tv).start();
            new Wather(tv).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 Wather extends Thread{ 
        TV tv;
        public Wather(TV tv) { 
            this.tv = tv;
        }
    
        @Override
        public void run() { 
            for (int i = 0; i < 20; i++) { 
                tv.watch();
            }
        }
    }
    
    class TV{ 
        // 演员表演，观众等待 T
        // 观众观看，演员等待 F
        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 = !flag;
        }
        //观看
        public synchronized void watch(){ 
            if(flag){ 
                try { 
                    this.wait();
                } catch (InterruptedException e) { 
                    e.printStackTrace();
                }
            }
            System.out.println("观众观看了:"+voice);
            //通知演员表演了
            this.notifyAll();
            this.flag = !flag;
        }
    }

## 线程池 ##

在并发的情况下，对线程的性能影响很大，所以可以提前创建好多个线程，放入线程池中，使用时直接获取，使用完毕后放入线程池

好处

*  提高响应速度，减少了线程的创建时间
 *  降低资源消耗，重复利用线程池的线程
 *  便于线程的管理

public class TestPool { 
        public static void main(String[] args) { 
            //1、创建服务，创建线程池
            // Executors 工具类，线程池的工厂类，用于创建并返回不同类型的线程池
            ExecutorService service = Executors.newFixedThreadPool(10);
    
    
            //2、把线程丢进去
            service.execute(new MyThread());
            service.execute(new MyThread());
            service.execute(new MyThread());
            service.execute(new MyThread());
    
            //3、关闭连接
            service.shutdown();
        }
    }
    
    class MyThread implements Runnable{ 
        @Override
        public void run() { 
            System.out.println(Thread.currentThread().getName());
        }
    }