Java线程的同步

2021-12-16 08:39:15

线程同步

  • 用在多个线程操作同一个资源的时候

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

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

队列和锁

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

    • 一个线程持有锁会导致其他所有需要此锁的线程挂起

    • 在多线竞争下，加锁和释放锁会导致比较多的上下文切换以及调度延时，存在性能方面的问题。

    • 如果一个优先级高的线程等待一个优先级低的线程释放锁，会存在优先级倒置的性能问题（很快解决的事被很慢解决的事堵塞）。

三大不安全案例

  • 不安全的买票

package com.kuang.syn;
//不安全的买票
//线程不安全，有负数。
public class UnsafeBuyTicket{
    public static void main(String[] args){
        BuyTicket station = new BuyTicket();
        new Thread(staion, "11").start();
        new Thread(staion, "22").start();
        new Thread(staion, "33").start();
    }
}
​
class BuyTicket implements Runnable{
    //票
    private int ticketNums = 10;
    boolean flag = true; //外部停止方式
    @Override
    public void run(){
        //买票
        while (flag){
            try{
                buy();
            }catch (InterruptedException e){
                e.printStackTrace();
            }
        }
    }
    
    private void buy() throws InterruptedException{
        //判断是否有票
        if (ticketNums <= 0){
            flag = false;
            return;
        }
        //模拟延时，放大问题的发生概率。
        Thread.sleep(100);
    }
    //买票
    System.out.println(Thread.currentThread().getName() + "拿到" + ticketNums--);
}
package com.kuang.syn;
//不安全的取钱
//两个人去银行取同一个账户的钱
public class UnsafeBank{
    public static void main(String[] args){
        //取钱先得有账户
        Account account = new Account(100, "基金");
        Drawing you = new Drawing(account, 50, "你");
        Drawing gf = new Drawing(account, 100, "你对象");
        
        you.start();
        gf.start();
    }
}
//账户
class Account{
    private int money; //余额
    private String name; //卡名
    
    public Account(int money, String name){
        this.money = money;
        this.name = name;
    }
}
//银行
class Drawing extends Thread{
    Account account; //账户
    //取了多少钱
    int drawingMoney;
    //现在手里有多少钱
    int nowMoney;
    
    public Drawing(Account account, int drawingMoney, String name){
        super(name); //这个name是线程的名字，调用父类有参构造方法，传入名字。
        this.account = account;
        this.drawingMoney = drawingMoney;
    }
    //取钱
    @Override
    public void run(){
        //判断有没有钱
        if (account.money - drawingMoney < 0){
            System.out.println(Thread.currentThread().getName() + "余额不足");
            return;
        }
        
        //模拟一个延时，提升问题暴露概率。
        try {
            Thread.sleep(1000);
        }catch (InterruptedException e){
            e.printStackTrace();
        }
        
        //卡内余额
        account.money = account.money - drawingMoney;
        //你手里的钱
        nowMoney = nowMoney + drawingMoney;
        
        System.out.println(account.name + "余额为:" + account.money);
        //Thread.currentThread().getName() = this.getName() 因为Drawing继承了Thread全部方法，它就可以调用this.getName()获取线程名字。
        System.out.println(this.getName() + "手里的钱:" + nowMoney);
    }
}
package com.kuang.syn;
​
import java.util.ArrayList;
import java.util.List;
//线程不安全的集合，多个线程同一时间把同一内容加到同一位置。
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();
        }
        try{
            Thread.sleep(3000);
        }catch (InterruptedException e){
            e.printStackTrace();
        }
        System.out.println(list.size());
    }
}

同步开始

  • 由于我们可以通过 private 关键字来保证数据对象只能被方法访问，所以我们只需要针对方法提出一套机制，这套机制就是synchronized关键字，它包括两种方法：synchronized方法和synchronized块。

  • 同步方法：public synchronized void method(int args){}

  • synchronized方法控制对”对象“的访问，每个对象对应一把锁，每个synchronized方法都必须获得调用该方法的对象的锁才能执行，否则线程会阻塞，方法一旦执行就独占该锁，直到该方法返回才释放锁，后面被阻塞的线程才能获得这个锁，得以继续执行。

  • 缺陷：若将一个大的方法声明为synchronized将会影响其执行效率

  • 方法里面需要修改的内容才会需要锁

同步块

  • 同步块：synchronized (Obj){}

  • 在三大不安全方法的 run 方法那儿加上synchronized 变成同步方法，就可以解决线程的抢占行为（这里是对象锁，还不是类锁。）。

  • Obj 称为同步监视器

    • Obj可以是任何对象，但是推荐使用 共享资源(不能被同时使用) 作为同步监视器。

    • 同步方法中无需指定同步监视器，因为同步方法的同步监视器就是 this ，即这个对象本身，或者是 class【反射中会讲】。

  • 同步监视器的执行过程：

    • 第一个线程访问，锁定同步监视器，执行其中代码。

    • 第二个线程访问，发现同步监视器被锁定，无法访问。

    • 第一个线程访问完毕，解锁同步监视器。

    • 第二个线程访问，发现同步监视器没有锁，当即锁定并访问。

  • 共享资源侧操作应该放在同步方法内，放在同步块外，无法避免同步问题。

//买票用synchronized锁买票的对象方法，现在用同步块去锁银行账户。
@Override
public void run(){
    synchronized(account){
        //判断有没有钱
        if (account.money - drawingMoney < 0){
            System.out.println(Thread.currentThread().getName() + "余额不足");
            return;
        }
        
        //模拟一个延时，提升问题暴露概率。
        try {
            Thread.sleep(1000);
        }catch (InterruptedException e){
            e.printStackTrace();
        }
        
        //卡内余额
        account.money = account.money - drawingMoney;
        //你手里的钱
        nowMoney = nowMoney + drawingMoney;
        
        System.out.println(account.name + "余额为:" + account.money);
        //Thread.currentThread().getName() = this.getName() 因为Drawing继承了Thread全部方法，它就可以调用this.getName()获取线程名字。
        System.out.println(this.getName() + "手里的钱:" + nowMoney);
    }
}

Copy On Write Array List

  • JUC下的包

package com.kuang.syn;
//测试JUC安全类型的集合
import java.util.concurrent.CopyOnWriteArrayList;
​
public class TestJUC{
    public static void main(String[] args){
        CopyOnWriteArrayList<String> list = new CopyOnWriteArrayList<String>();
        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());
    }
}

 

上一篇：21-Spring5 使用GenericApplicationContext创建IOC容器


下一篇：同步方法及同步块