【Thread】线程的同步机制（三）

小咪咪 2023-10-02 12:57 8阅读 0赞

### 1. 线程不安全案例 ###

线程同步：多个线程同时操作同一个资源（并发）

处理多线程问题时，多个线程访问同一个对象，并且某个线程还想修改这个对象，这个时候我们就需要 线程同步。

**线程同步** 其实就是一个等待机制，多个需要同时访问此对象的线程进入这个对象的等待池形成队列，等待前面的线程使用完毕，下一个线程再使用。

由于同一个进程的多个线程共享同一块存储空间，在带来方便的同时，也带来了访问冲突的问题，为了保证数据在方法中被访问时的正确性，在访问时加入了锁机制 synchronized，当一个线程获得对象的排它锁，独占资源，其它线程必须等待，使用后释放锁即可。

线程同步的形成条件：等待队列 \+ 锁

但存在以下问题：

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

接下来咱们来看看几个线程不安全的例子吧~

> 案例一：不安全地买票

买票的线程：

class BuyTicket implements Runnable {
        
    	// 总票数
        private int ticketNums = 10;
        // 是否有票标识
        private boolean flag = true;
    
        @Override
        public void run() {
        
            while (flag) {
        
            	// 买票
                buyTicket();
            }
        }
    
        public void buyTicket() {
        
            if (ticketNums <= 0) {
        
                flag = false;
                return;
            }
            // 模拟延迟
            try {
        
                Thread.sleep(100);
            } catch (Exception e) {
        
                e.printStackTrace();
            }
            System.out.println(Thread.currentThread().getName() + "拿到了第" + ticketNums-- + "张票");
        }
    }

测试：有三个人去买票

public class UnSafeBuyTicket {
        
    
        public static void main(String[] args) {
        
            BuyTicket buyTicket = new BuyTicket();
    
            new Thread(buyTicket, "苦逼的我").start();
            new Thread(buyTicket, "牛逼的你").start();
            new Thread(buyTicket, "可恶的他").start();
        }
    }

运行结果如下：  
![在这里插入图片描述][watermark_type_ZHJvaWRzYW5zZmFsbGJhY2s_shadow_50_text_Q1NETiBAc2NvNTI4Mg_size_15_color_FFFFFF_t_70_g_se_x_16]  
有可能有的人买的是负数票（票卖超了）；有可能人两个人买的是同一张票

> 案例二：不安全地去银行取钱

// 账户
    class Account {
        
    	// 余额
        private int money;
        // 户主
        private String name;
    
        public int getMoney() {
        
            return money;
        }
    
        public void setMoney(int money) {
        
            this.money = money;
        }
    
        public String getName() {
        
            return name;
        }
    
        public void setName(String name) {
        
            this.name = name;
        }
    }
    
    // 取钱的线程
    class Drawing extends Thread {
        
    
        private Account account;
        // 取多少钱
        private int drwaingMoney;
        // 现在手里多少钱
        private int nowMoney;
    
        public Drawing(Account account, int drwaingMoney, String name) {
        
            super(name);
            this.account = account;
            this.drwaingMoney = drwaingMoney;
        }
    
        @Override
        public void run() {
        
            if (account.getMoney() - drwaingMoney < 0) {
        
                System.out.println(Thread.currentThread().getName() + "钱不够，取不了");
                return;
            }
            // 模拟延迟
            try {
        
                Thread.sleep(1000);
            } catch (InterruptedException e) {
        
                e.printStackTrace();
            }
            // 账户上的钱
            account.setMoney(account.getMoney() - drwaingMoney);
            // 手上的钱
            nowMoney = nowMoney + drwaingMoney;
            System.out.println(account.getName() + "余额为:" + account.getMoney());
            System.out.println(this.getName() + "手里的钱为:" + nowMoney);
        }
    }

测试：

public class UnSafeBank {
        
    
        public static void main(String[] args) {
        
            Account account = new Account();
            account.setMoney(100);
            account.setName("zzc");
    
            Drawing you = new Drawing(account, 50, "你");
            Drawing girlFriend = new Drawing(account, 100, "对象");
    
            you.start();
            girlFriend.start();
        }
    }

运行结果如下：  
![在这里插入图片描述][watermark_type_ZHJvaWRzYW5zZmFsbGJhY2s_shadow_50_text_Q1NETiBAc2NvNTI4Mg_size_14_color_FFFFFF_t_70_g_se_x_16]  
总账户只有 100，你取了 50 ，你对象还能取 100。（实际上取不了，两人只能有一个人取钱成功）

> 案例三：线程不安全的集合

public class UnSafeList {
        
    
        public static void main(String[] args) throws Exception{
        
            List<String> list = new ArrayList<>();
            for (int i = 0; i < 10000; i++) {
        
                new Thread(() -> {
        
                    list.add(Thread.currentThread().getName());
                }).start();
            }
            Thread.sleep(3000);
            System.out.println(list.size());
        }
    }

运行上述程序后：  
![在这里插入图片描述][41304428bb5b4756ace5652651b64258.png]  
往集合中添加 1万 条数据，结果集合的大小只有 6825

### 2. 同步方法和同步代码块 ###

同步方法：

public synchronized void method(int args) {
        }

`synchronized` 方法控制对对象的访问，每个对象对应一把锁，每个 `synchronized` 方法都必须获得调用该方法的对象锁才能执行，否则，线程会阻塞。方法一旦执行，就独占该对象锁，知道该方法执行结束后才释放锁，后面被阻塞的线程才能获得这个锁，继续执行。

缺陷：若将一个大的方法申明为 `synchronized` 将会影响效率

所以，**同步代码块**就应运而生了。

同步代码块只锁修改的内容，只读的内容不锁，减少资源的浪费。

同步代码块：

synchronized (Obj) {
        }

Obj：同步监视器

*  Obj 可以是任何对象，但推荐使用共享资源作为同步监视器

同步监视器的执行过程：

1.  第一个线程访问：锁定同步监视器，执行其中的代码
2.  第二个线程访问：发现同步监视器被锁定，无法访问
3.  第一个线程访问完毕：解除同步监视器
4.  第二个线程访问：发现同步监视器没有锁，然后锁定并访问

接下来将上述的3个线程不安全案例修改为线程安全的案例

> 案例四：线程安全地买票

class BuyTicket implements Runnable {
        
    
        ...
    
    	// 修改为同步方法
        public synchronized void buyTicket() {
        
            if (ticketNums <= 0) {
        
                flag = false;
                return;
            }
            // 模拟延迟
            try {
        
                Thread.sleep(100);
            } catch (Exception e) {
        
                e.printStackTrace();
            }
            System.out.println(Thread.currentThread().getName() + "拿到了第" + ticketNums-- + "张票");
        }
    }

运行结果后：  
![在这里插入图片描述][watermark_type_ZHJvaWRzYW5zZmFsbGJhY2s_shadow_50_text_Q1NETiBAc2NvNTI4Mg_size_13_color_FFFFFF_t_70_g_se_x_16]

> 案例五：线程安全地取钱

class Drawing extends Thread {
        
    
        ...
    
        @Override
        public void run() {
        
        	// 修改为同步代码块
            synchronized (account) {
        
                if (account.getMoney() - drwaingMoney < 0) {
        
                    System.out.println(Thread.currentThread().getName() + "钱不够，取不了");
                    return;
                }
                // 模拟延迟
                try {
        
                    Thread.sleep(100);
                } catch (InterruptedException e) {
        
                    e.printStackTrace();
                }
                // 账户上的钱
                account.setMoney(account.getMoney() - drwaingMoney);
                // 手上的钱
                nowMoney = nowMoney + drwaingMoney;
                System.out.println(account.getName() + "余额为:" + account.getMoney());
                System.out.println(this.getName() + "手里的钱为:" + nowMoney);
            }
        }
    }

【注意】：同步代码块锁的对象是，需要增、删、改的对象（共享资源）

运行结果后：  
![在这里插入图片描述][eaf49f7019ca406595169ff6c7d12fc8.png]

> 案例六：线程安全的集合

public class UnSafeList {
        
    
        public static void main(String[] args) throws Exception{
        
            List<String> list = new ArrayList<>();
            for (int i = 0; i < 10000; i++) {
        
                new Thread(() -> {
        
                	// 修改同步代码块
                    synchronized (list) {
        
                        list.add(Thread.currentThread().getName());
                    }
                }).start();
            }
            Thread.sleep(3000);
            System.out.println(list.size());
        }
    }

[watermark_type_ZHJvaWRzYW5zZmFsbGJhY2s_shadow_50_text_Q1NETiBAc2NvNTI4Mg_size_15_color_FFFFFF_t_70_g_se_x_16]: https://img-blog.csdnimg.cn/b042c45161bc4f23b8971ebd6a89ed1b.png?x-oss-process=image/watermark,type_ZHJvaWRzYW5zZmFsbGJhY2s,shadow_50,text_Q1NETiBAc2NvNTI4Mg==,size_15,color_FFFFFF,t_70,g_se,x_16
[watermark_type_ZHJvaWRzYW5zZmFsbGJhY2s_shadow_50_text_Q1NETiBAc2NvNTI4Mg_size_14_color_FFFFFF_t_70_g_se_x_16]: https://img-blog.csdnimg.cn/b342a92c88654e788807aebf14542fdb.png?x-oss-process=image/watermark,type_ZHJvaWRzYW5zZmFsbGJhY2s,shadow_50,text_Q1NETiBAc2NvNTI4Mg==,size_14,color_FFFFFF,t_70,g_se,x_16
[41304428bb5b4756ace5652651b64258.png]: https://img-blog.csdnimg.cn/41304428bb5b4756ace5652651b64258.png
[watermark_type_ZHJvaWRzYW5zZmFsbGJhY2s_shadow_50_text_Q1NETiBAc2NvNTI4Mg_size_13_color_FFFFFF_t_70_g_se_x_16]: https://img-blog.csdnimg.cn/fbe16a371acd455db51d5ca0a73287b1.png?x-oss-process=image/watermark,type_ZHJvaWRzYW5zZmFsbGJhY2s,shadow_50,text_Q1NETiBAc2NvNTI4Mg==,size_13,color_FFFFFF,t_70,g_se,x_16
[eaf49f7019ca406595169ff6c7d12fc8.png]: https://img-blog.csdnimg.cn/eaf49f7019ca406595169ff6c7d12fc8.png