多线程：6-锁

2020-06-05 阅读量

6.锁

1.死锁

在线程间共享多个资源的时候，如果几个线程分别占有一部分资源不释放，并且大家都等待对方释放资源，就会造成死锁。（多个线程互相抱着对方需要的资源不放，形成僵持。）
某一个同步块同时拥有“两个以上对象的锁”时，就可能发生“死锁”的问题。

产生死锁的四个必要条件：

互斥条件：一个资源每次只能被一个进程使用。
请求和保持条件：一个进程因请求资源而阻塞时，对已获得的资源保持不放。
不剥夺条件：进程已获得的资源，在未使用完之前，不能强行剥夺。
循环等待条件：若干进程之间形成一种头尾相接的循环等待资源关系。

避免死锁：

上面列出的4个条件，破坏其中的一个或多个，就能避免死锁。
不要在一个代码块当中，同时持有多个对象的锁（即不要锁套锁）

举例：

/**
 *  代码多运行几遍 - 就可能会发现死锁的情况 如下：
 *  1号人获得镜子
 *  2号人获得口红      
 */


public class DeadLock {

	public static void main(String[] args) {
		
		Markup g1 = new Markup(1, "1号人");
		Markup g2 = new Markup(2, "2号人");
		
		g1.start();
		g2.start();
	}
}


//口红
class Lipstick{
	
}

//镜子
class Mirror{
	
}

//化妆
class Markup extends Thread{
	
	//只有一个口红 一面镜子  所以加个静态 表示就这一份 不管创建几个对象
	static Lipstick lipstick = new Lipstick();
	static Mirror mirror = new Mirror();
	
	int choice;     //选择
	String girl;    //名字
	
	public Markup(int choice, String girl) {
		this.choice = choice;
		this.girl = girl;
	}
	
	public void run() {
		//化妆
		mark();
	}
	
	//相互持有对方的对象锁 --> 可能造成死锁
	private void mark() {
		
		if(choice == 0) {
			synchronized(lipstick) {  //获得口红的锁
				System.out.println(this.girl + "获得口红");
				
				//1s后想拥有镜子的锁
				try {
					Thread.sleep(1000);
				} catch (InterruptedException e) {
					e.printStackTrace();
				}
				
				synchronized(mirror) {  //获得镜子的锁
					System.out.println(this.girl + "获得镜子");
				}
			}
			/*
			 * 把上面的代码块  挪到这个位置  就解决了死锁的问题
			 * 不要锁套锁 就行了
			 * 同理 下面的代码也是一样的
			synchronized(mirror) {  //获得镜子的锁
				System.out.println(this.girl + "获得镜子");
			}
			 */
		}else {
			synchronized(mirror) {  //获得镜子的锁
				System.out.println(this.girl + "获得镜子");
				
				//2s后想拥有口红的锁
				try {
					Thread.sleep(2000);
				} catch (InterruptedException e) {
					e.printStackTrace();
				}
				
				synchronized(lipstick) {  //获得口红的锁
					System.out.println(this.girl + "获得口红");
				}
			}	
		}
	}
	
}

2.Lock（锁）

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

Lock大致格式：

class A{

    // 定义lock锁
    private final ReentrantLock rLock = new ReentrantLock();

    public void test(){
        rLock.lock();  //加锁

        try{
            // 需要保证线程安全的代码
        }finally {
            // 如果同步代码有异常，要将unlock() 写在finally语句块里
            rLock.unlock();  // 解锁
        }
    }
}

测试：
1.不安全写法：

// 测试Lock锁
public class TestLock {
    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 ticketNums = 5;  // 票数量

    @Override
    public void run() {
        // 买票
        while (true){
            if(ticketNums <= 0){
                break;
            }else {
                // 买到票 票数减1
                System.out.println(ticketNums--);
            }
        }
    }
}

2.加lock锁改成安全写法：

// 测试Lock锁
public class TestLock {
    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 ticketNums = 5;  // 票数量

    // 定义lock锁
    private final ReentrantLock lock = new ReentrantLock();

    @Override
    public void run() {
        // 买票
        while (true){
            try{
                lock.lock(); // 加锁

                if(ticketNums <= 0){
                    break;
                }else {
                    // 买到票 票数减1
                    System.out.println(ticketNums--);
                }
            } finally {
                lock.unlock();  // 解锁
            }
        }
    }
}

3.synchronized 与 Lock对比

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