Java线程的同步机制

Java线程的同步机制

Java线程的同步机制

并发

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

  • 现实生活中,我们会遇到“同一个资源,多个人都想使用”的问题,比如,食堂排队打饭,每个人都想吃饭,最天然的解决办法就是,排队,一个个来。

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

队列和锁

  • 由于同一进程的多个线程共享同一块存储空间,在带来方便的同时,也带来了访问冲突问题,为了保证数据在方法中被访问时的正确性,在访问时加入锁机制synchronized,当一个线程获得对象的排它锁,独占资源,其他线程必须等待,使用后释放锁即可,存在以下问题:
    • 一个线程持有锁会导致其他所有需要此锁的线程挂起;
    • 在多线程竞争下,加锁,释放锁会导致比较多的上下文切换和调度延时,引起性能问题;
    • 如果一个优先级高的线程等待一个优先级低的线程释放锁会导致优先级倒置,引起性能问题。

三大不安全案例

不安全买票

package com.cnblogs.thread;
//不安全买票
//会买到0 甚至负数
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();
    }
}

class BuyTicket implements Runnable{

    private int TicketNum = 10;
    boolean flag = true;
    @Override
    public void run() {
        while(flag){
            try {
                buy();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }

    public  void buy() throws InterruptedException {
        if(TicketNum <= 0){
            flag = false;
            return;
        }
        Thread.sleep(1000);
        System.out.println(Thread.currentThread().getName() + "买到了第" + TicketNum-- + "张票!");
    }
}
/*
黄牛买到了第10张票!
你买到了第9张票!
我买到了第8张票!
黄牛买到了第7张票!
你买到了第6张票!
我买到了第5张票!
黄牛买到了第4张票!
你买到了第3张票!
我买到了第2张票!
黄牛买到了第1张票!
你买到了第0张票!
我买到了第-1张票!
 */

不安全取钱

package com.cnblogs.thread;
//不安全取钱
public class UnsafeBank {
    public static void main(String[] args) {
        Account account = new Account(200, "共同的基金");

        Bank you = new Bank(account,100,"你");
        Bank i = new Bank(account,200,"我");
        you.start();
        i.start();
    }
}


//账户
class Account{
    int money;
    String name;

    public Account(int money, String name) {
        this.money = money;
        this.name = name;
    }
}


//银行  模拟取款
class Bank extends Thread{
    Account account;//账户
    //取了多少钱
    int drawingMoney;
    //现在还剩多少钱
    int nowMoney;


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

    }

    @Override
    public void run() {
        if(account.money - drawingMoney < 0){
            System.out.println("钱不够了,取不了钱");
            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() 一样的
        System.out.println(this.getName() + "手里的钱" + nowMoney);
    }
}

/*
共同的基金余额为100
你手里的钱100
共同的基金余额为-100
我手里的钱200

这里还多取了100块钱,银行血亏啊
 */

不安全集合

package com.cnblogs.thread;

import java.util.ArrayList;
import java.util.List;

//线程不安全集合
public class UnsafeList {
    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(500);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println(list.size());
        /*
		9999
         */
    }
}

同步方法及同步方法块

同步方法

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

    • 同步方法:public synchronized void method(int args){}
  • synchronized方法控制对“对象”的访问,每个对象对应一把锁,每个synchronized方法都必须获得调用该方法的对象的锁才能执行,否则线程会阻塞,方法一旦执行,就独占该锁,直到该方法返回才释放锁,后面被阻塞的线程才能获得这个锁,继续执行

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

同步方法弊端

  • 方法里面需要修改的内容才需要锁,所得太多,浪费资源

同步块

  • 同步块:synchronized(Obj){}

  • Obj称为同步监听器

    • Obj可以是任何对象,但是推荐使用共享资源作为同步监听器
    • 同步方法中无需指定同步监视器,因为同步方法的同步监视器就是this,就是这个对象本身,或者是class
  • 同步监视器的执行过程

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

不安全买票的解决方案

方案一:同步方法

package com.cnblogs.thread;
//不安全买票 解决方案
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();
    }
}

class BuyTicket implements Runnable{

    private int TicketNum = 10;
    boolean flag = true;
    @Override
    public void run() {
        while(flag){
            try {
                buy();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }
    //同步方法
    public synchronized void buy() throws InterruptedException {
        if(TicketNum <= 0){
            flag = false;
            return;
        }
        Thread.sleep(1000);
        System.out.println(Thread.currentThread().getName() + "买到了第" + TicketNum-- + "张票!");
    }
}
/*
我买到了第10张票!
黄牛买到了第9张票!
黄牛买到了第8张票!
黄牛买到了第7张票!
你买到了第6张票!
你买到了第5张票!
你买到了第4张票!
你买到了第3张票!
黄牛买到了第2张票!
我买到了第1张票!
 */

方案二:同步代码块

package com.cnblogs.thread;
//不安全买票 解决方案
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();
    }
}

class BuyTicket implements Runnable{

    private int TicketNum = 10;
    boolean flag = true;
    Object o = new Object();
    @Override
    public void run() {
        while(flag){
            //同步代码块
            synchronized (o){
                try {
                    buy();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        }
    }
    public void buy() throws InterruptedException {
        if(TicketNum <= 0){
            flag = false;
            return;
        }
        Thread.sleep(1000);
        System.out.println(Thread.currentThread().getName() + "买到了第" + TicketNum-- + "张票!");
    }
}
/*
我买到了第10张票!
你买到了第9张票!
你买到了第8张票!
黄牛买到了第7张票!
黄牛买到了第6张票!
你买到了第5张票!
你买到了第4张票!
你买到了第3张票!
我买到了第2张票!
我买到了第1张票!
 */

不安全取钱的解决方案

package com.cnblogs.thread;
//不安全取钱,解决方案
public class UnsafeBank {
    public static void main(String[] args) {
        Account account = new Account(200, "共同的基金");

        Bank you = new Bank(account,100,"你");
        Bank i = new Bank(account,200,"我");
        you.start();
        i.start();
    }
}


//账户
class Account{
    int money;
    String name;

    public Account(int money, String name) {
        this.money = money;
        this.name = name;
    }
}


//银行  模拟取款
class Bank extends Thread{
    Account account;//账户
    //取了多少钱
    int drawingMoney;
    //现在还剩多少钱
    int nowMoney;


    public Bank(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("钱不够了,取不了钱");
                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() 一样的
            System.out.println(this.getName() + "手里的钱" + nowMoney);
        }
    }
}

/*
共同的基金余额为100
你手里的钱100
钱不够了,取不了钱
 */

不安全集合的解决方案

package com.cnblogs.thread;

import java.util.ArrayList;
import java.util.List;

//线程不安全集合,解决方案
public class UnsafeList {
    public static void main(String[] args) {
        List<String> list = new ArrayList<>();
        for (int i = 0; i < 10000; i++) {
            new Thread(() -> {
                synchronized (list){
                    list.add(Thread.currentThread().getName());
                }
            }).start();
        }
        try {
            Thread.sleep(500);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println(list.size());
        /*
        10000
         */
    }
}

死锁

  • 多个线程各自占有一些共享资源,并且互相等待其他线程占有的资源才能运行,而导致两个或多个线程都在等待对方释放资源,都停止执行的情形,某个同步块同时拥有“两个以上对象的锁”时,就可能会发生“死锁”的问题

死锁的案例

package com.cnblogs.thread;
//死锁的案例
public class DeadLock {
    public static void main(String[] args) {
        Makeup g1 = new Makeup(0, "女一");
        Makeup g2 = new Makeup(1, "女二");

        g1.start();
        g2.start();
        //程序就会卡死,死锁
    }
}
//口红
class LipsLick{

}
//镜子
class Mirror{

}

class Makeup extends Thread{
    //用static保证资源只有一份
    static LipsLick lipsLick = new LipsLick();
    static Mirror mirror = new Mirror();

    int choice;//选择
    String name;//人

    public Makeup(int choice , String name){
        this.choice = choice;
        this.name = name;
    }

    @Override
    public void run() {
        //化妆
        try {
            makeup();
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }

    public void makeup() throws InterruptedException {
        if(choice == 0){
            synchronized (lipsLick){//获得口红的锁
                System.out.println(this.name + "获得了口红的锁");
                Thread.sleep(1000);
                synchronized (mirror){//一秒后想获得镜子
                    System.out.println(this.name + "获得了镜子的锁");
                }
            }
        }else{
            synchronized (mirror){//获得口红的锁
                System.out.println(this.name + "获得了镜子的锁");
                Thread.sleep(2000);
                synchronized (lipsLick){//两秒后想获得口红
                    System.out.println(this.name + "获得了口红的锁");
                }
            }
        }
    }
}
package com.cnblogs.thread;
//死锁案例解决方案
public class DeadLock {
    public static void main(String[] args) {
        Makeup g1 = new Makeup(0, "女一");
        Makeup g2 = new Makeup(1, "女二");

        g1.start();
        g2.start();
    }
}
//口红
class LipsLick{

}
//镜子
class Mirror{

}

class Makeup extends Thread{
    //用static保证资源只有一份
    static LipsLick lipsLick = new LipsLick();
    static Mirror mirror = new Mirror();

    int choice;//选择
    String name;//人

    public Makeup(int choice , String name){
        this.choice = choice;
        this.name = name;
    }

    @Override
    public void run() {
        //化妆
        try {
            makeup();
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }

    public void makeup() throws InterruptedException {
        if(choice == 0){
            synchronized (lipsLick){//获得口红的锁
                System.out.println(this.name + "获得了口红的锁");
                Thread.sleep(1000);
            }
            synchronized (mirror){//一秒后想获得镜子
                System.out.println(this.name + "获得了镜子的锁");
            }
        }else{
            synchronized (mirror){//获得口红的锁
                System.out.println(this.name + "获得了镜子的锁");
                Thread.sleep(2000);
            }
            synchronized (lipsLick){//两秒后想获得口红
                System.out.println(this.name + "获得了口红的锁");
            }
        }
    }
}

死锁避免的方法

  • 产生死锁的四个必要条件:
    1. 互斥条件:一个资源每次只能被一个进程使用。
    2. 请求与保持条件:一个进程因请求资源而阻塞时,对已获得的资源保持不放。
    3. 不剥夺条件:进程已获得资源,在未使用完之前,不能强行剥夺。
    4. 循环等待条件:若干进程之间形成一种头尾相接的循环等待资源关系。

Lock(锁)

  • 从JDK5.0开始,Java提供了跟强大的同步机制,通过显示定义同步锁对象来实现同步。同步锁使用Lock锁对象充当
  • java.util.concurrent.locks.Lock接口是控制多个线程对共享资源进行访问的工具。锁提供了对共享资源的独占访问,每次只能有一个线程对Lock锁对象加锁,线程开始访问共享资源之前应先获得Lock对象
  • ReentrantLock类实现了Lock,它拥有与synchronized相同的并发性和内存语义,在实现线程安全的控制中,比较常用的是ReentrantLock,可以显式加锁、释放锁。

Lock锁的语法格式

class A{
    private final ReentrantLock lock = new ReentrantLock();
    public void method(){
        lock.lock();
        try{
            //需要保证线程安全的代码
        }finally{
            lock.unlock();
        }
    }
}

Lock锁的案例

package com.cnblogs.thread;

import java.util.concurrent.locks.ReentrantLock;

public class TestLock {
    public static void main(String[] args) {
        TestLock2 t = new TestLock2();
        new Thread(t).start();
        new Thread(t).start();
        new Thread(t).start();
    }
}


class TestLock2 implements Runnable{

    int ticketNum = 10;
    //定义Lock锁
    private final ReentrantLock lock = new ReentrantLock();

    @Override
    public void run() {
        while(true){
            lock.lock();
            try {
                if(ticketNum > 0){
                    try {
                        Thread.sleep(1000);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                    System.out.println(ticketNum--);
                }else {
                    break;
                }
            }finally {
                lock.unlock();
            }
        }
    }
}

synchronized和Lock的对比

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