【多线程】线程锁

最新推荐文章于 2024-09-15 09:47:04 发布

~菜鸟笔记~

最新推荐文章于 2024-09-15 09:47:04 发布

阅读量526

点赞数 16

文章标签： java 开发语言

本文链接：https://blog.csdn.net/m0_63789588/article/details/141169849

版权

死锁案例

public class TestLock {
    public static void main(String[] args) {
//        implements Runnable用
//        Thread thread=new Thread(new MakeUp(0,"小白"));
//        Thread thread2=new Thread(new MakeUp(1,"小花"));
//        extends Thread用
        MakeUp thread=new MakeUp(0,"小白");
        MakeUp thread2=new MakeUp(1,"小花");

        thread.start();
        thread2.start();
    }
}

class Lipstick{

}

class Mirror{

}

//化妆的方法
class MakeUp extends Thread {

    static Lipstick lipstick = new Lipstick();
    static Mirror mirror = new Mirror();

    int choice;//选择
    String girlName;//名字

    public 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(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+"拿到镜子");
                }
            }
        }
    }
}

解决方法，把对方的锁拿出去

产生死锁条件

1，互斥条件：一个资源一次只能被一个进程使用

2，请求与保持：一个进程因请求资源而阻塞时，对已经获得的资源保持不放

3，不剥夺：进程已获得资源，在未使用完之前，不能强行剥夺

4，循环等待：若干进行之间形成一种头尾相接的循环等待资源关系

上述4各个条件，破坏其中一个，就可以避免死锁发生

Lock锁

1，JDK5.0开始，java提供了更强大的线程同步机制-----通过显示定义同步锁对象来实现同步，同步锁使用Lock对象来充当

2，java.util;concurrent.licks.Lock接口（JUC）是控制多个线程对共享资源进行访问的工具，锁提供了对共享资源的独占访问，每次只能有一个线程对Lock对象加锁，线程开始访问共享资源之前应该先获得Lock对象

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

之前买票案例加所

import java.util.concurrent.locks.ReentrantLock;

public class TestLock2 implements Runnable{
    boolean flag=true;
    private int ticketNum=10;//定义票数
    //定义lock锁
    private final ReentrantLock lock=new ReentrantLock();

    @Override
    public void run() {
        while (true){
            buy();
        }
    }
    public static void main(String[] args) {
        TestLock2 testThread1=new TestLock2();
        //多个线程使用一个,第二个参数，可以给线程命名
        new Thread(testThread1,"张三").start();
        new Thread(testThread1,"李四").start();
        new Thread(testThread1,"王麻子").start();

    }

    private void buy(){
        try{
            lock.lock();//加锁
            //如果票没了，就停止
            if(ticketNum<=0){
                flag=false;
                return;
            }
            //模拟一个延时，否则太快，看不出来同步执行
            try {
                Thread.sleep(20);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            //获取当前线程名字Thread.currentThread().getName()
            System.out.println(Thread.currentThread().getName()+"买到了第"+ticketNum--+"张票");
        }catch (Exception e){

        }finally {
            lock.unlock();//解锁
        }

    }
}