第七天学习多线程同步和锁

多线程的线程同步和锁

线程同步

当多个线程访问同一个对象,并且线程还想修改对象,这时候就需要线程同步,线程同步其实就是一个等待机制,多个需要访问此对象的线程进入对象的等待池形成队列,等待前一个线程使用完毕,下一个线程再使用。

  • 线程同步的形成条件:队列+锁

队列

  • 线程排队。

锁_synchronized隐式定义锁

  • 一个线程持有锁会导致其他所有需要此锁的线程挂起。
  • 多线程竞争下,加锁,释放锁对导致较多的上下文切换和调度问题,引起性能问题。
  • 如果一个优先级高的线程等待一个优先级低的线程释放锁,会导致优先级倒置,引起性能问题。
  • 方法里需要修改的内容才需要锁,锁太多,资源浪费。
  • 总之就是性能下降!
public synchronized void method(){}
  • 默认的synchronized修饰词锁的是this(类本身)。
  • synchronized同步块锁的是任何对象。

怎么判断该锁谁!

package syn;

//不安全取钱
//两个人去银行取钱
//银行需要账户
public class UnsafeBank {

    public static void main(String[] args) {
        Account account = new Account(1000,"结婚基金");
        Drawing you = new Drawing(account,50,"你");
        Drawing girl = new Drawing(account,100,"你老婆");
        you.start();
        girl.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 drawingMoney;
    int nowMoney;

    public Drawing(Account account, int drawingMoney, String name){
        super(name);
        this.account = account;
        this.drawingMoney = drawingMoney;
    }

    @Override
    public void run() {

        synchronized (account){

            //判断有没有钱
            if (account.money-drawingMoney<0){
                System.out.println(Thread.currentThread().getName()+"取光了钱");
                return;
            }
            try {
                Thread.sleep(100);
            } catch (InterruptedException e) {
            }
            account.money = account.money-drawingMoney;
            nowMoney = nowMoney +drawingMoney;
            System.out.println(account.name+"余额为:"+account.money);
            System.out.println(Thread.currentThread().getName()+"手里的钱:"+nowMoney);

        }
        
    }
}

  • 首先应该为进行数据增、删、改的地方加锁。
  • 上述代码中run方法中加锁的话默认锁住了本类(银行),但银行并没有变化,变化的是账户的钱。
  • 这时使用同步代码块,参数放入账户的钱,修改语句放在块里即可锁住。

死锁

  • 多个线程互相抱着对方需要的资源,然后形成僵持
package syn;

//死锁:多个线程互相抱着对方需要的资源,然后形成僵持
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保证唯一)
    static Lipstick lipstick = new Lipstick();
    static Mirror mirror = new Mirror();

    int choise; //选择
    String girlName;//使用化妆品的人

    Makeup(int choise, String girlName) {
        this.choise = choise;
        this.girlName = girlName;
    }

    @Override
    public void run() {
        try {
            makeup();
        } catch (InterruptedException e) {

        }
    }

    //互相持有对方的锁(需要拿到对方的资源)
    private void makeup() throws InterruptedException {

        if (choise == 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 + "获得了口红的锁");
                }
            }
        }
    }
}
  • 互斥条件:一个资源每次只能被一个进程使用。
  • 请求与保持条件:一个进程因请求资源而阻塞时,对以获得的资源保持不放。
  • 不剥夺条件:进程已获得的资源,在未使用之前,不能强行剥夺。
  • 循环等待条件:若干进程之间形成一种头尾相接的循环等待资源关系。

只要解决以上一条即可避免死锁(锁不能嵌套锁!)

Lock锁_显式定义锁

ReentrantLock(可重入锁)类实现了Lock

class A {
    private final ReentrantLock lock = new ReenTrantLock();
    
    public void m(){
        lock.lock();//上锁
        try{
            //保证线程安全的代码
        }finally{
            lock.unlock();//开锁
        }
    }
}

synchronized与Lock对比

  1. Lock是显式锁,手动开启后需要关闭,synchronized是隐式锁,出了作用域自动释放。
  2. Lock只有代码块锁,synchronized有代码块锁和方法锁。
  3. Lock锁性能更好,JVM花费的调度时间更少,性能和扩展性都更好。
  4. 优先使用顺序:Lock>synchronized代码块>synchronized方法锁
posted @ 2020-05-15 19:31  yukinon  阅读(145)  评论(0编辑  收藏  举报