线程的基础知识（四）

骑猪看日落 2021-12-10 08:13 204阅读 0赞

本博客整理来源于《疯狂java讲义》。

## 线程同步 ##

1.  因为run()方法的方法体不具有同步安全性，为了解决这个问题，Java的多线程引入了同步监视器来解决这个问题，使用同步监视器的通用方法就是同步代码块。格式如下：

synchronized (obj) {
    				...
    				//同步代码块
    }

1.  任何时刻只有一个线程可以获得对同步监视器的锁定，当同步代码块执行完毕后，该线程会释放对该同步监视器的锁定。**通常推荐使用可能被并发访问的共享资源充当同步监视器。**
2.  与同步代码块对应的是同步方法。对于synchronized修饰的实例方法而言，无须显式指定同步监视器，同步方法的同步监视器是this，也就是调用该方法的对象。

## 关于释放同步监视器的锁定： ##

线程会在如下几种情况下释放锁：

1.  当前线程的同步方法，同步代码块执行结束；
2.  当前线程的同步方法，同步代码块遇到break，return终止了改代码块，该方法的继续执行；
3.  同步代码块，同步方法中出现了error或Exception，导致改代码块，该方法异常结束；
4.  同步代码块，同步方法中执行了同步监视器对象的wait()方法，则当前线程暂停，并释放同步监视器。

线程不会释放锁的情况：

1.  线程执行同步代码块或同步方法时，程序调用Thread.sleep()，Thread.yield()方法来暂停当前线程的执行，当前线程不会释放同步监视器。

## 同步锁：Lock ##

从Java 5 开始，Java提供了一种功能更强大的线程同步机制：通过显式定义同步锁对象来实现同步，在这种机制下，同步锁有Lock对象充当。  
代码演示如下：

package com.dalingjia.thead;
    
    import java.util.concurrent.locks.Lock;
    import java.util.concurrent.locks.ReentrantLock;
    
    public class Account {
    
    	//定义锁对象(可重入锁)，避免使用对象锁
    	private final Lock lock = new ReentrantLock();
    	
    	private String accountNo;
    	private Double balance;
    	
    	public String getAccountNo() {
    		return accountNo;
    	}
    	public void setAccountNo(String accountNo) {
    		this.accountNo = accountNo;
    	}
    	
    	public Double getBalance() {
    		return balance;
    	}
    	
    	public Account(String accountNo, Double balance) {
    		super();
    		this.accountNo = accountNo;
    		this.balance = balance;
    	}
    	public Account() {
    		super();
    	}
    
    	//提供一个线程安全的draw()方法来完成取钱操作
    	public void draw(Double drawAmount){
    		//加锁
    		lock.lock();
    		try {
    			if (balance >= drawAmount) {
    				System.out.println(Thread.currentThread().getName() + "取钱成功，吐钞票：" + drawAmount);
    				try {
    					Thread.sleep(1000);
    				} catch (InterruptedException e) {
    					e.printStackTrace();
    				}
    				balance -= drawAmount;
    				System.out.println("余额为：" + balance);
    			} else {
    				System.out.println("余额不足，取钱失败");
    			}
    			//修改完成后，释放锁
    		} finally {
    			lock.unlock();
    		}
    	}
    }
    
    package com.dalingjia.thead;
    
    public class AmountTest extends Thread{
    
    	//创建一个账户
    	private static final Account ACCOUNT = new Account("100001",10000.00);
    	
    	public AmountTest(String name){
    		super(name);
    	}
    	
    	public void run(){
    		ACCOUNT.draw(8000.00);
    	}
    	
    	public static void main(String[] args) {
    		new AmountTest("甲").start();
    		new AmountTest("乙").start();
    	}
    }

1.  使用Lock与使用同步方法有点相似，只是使用Lock时显式使用Lock对象作为同步锁，而使用同步方法时系统隐式使用当前对象作为同步监视器。
2.  ReentrantLock锁具有可重入性，即一个线程可以对已被加锁的ReentrantLock锁再次加锁，ReentrantLock对象会维持一个计数器来追踪Lock方法的嵌套调用，线程在每次调用lock()加锁后，必须显示调用unlock()来释放锁，所以一段被锁保护的代码可以调用另一个被相同锁保护的方法。

## 死锁： ##

当两个线程相互等待对方释放同步监视器时就会发生死锁，代码演示如下：

package com.dalingjia.thead;
    
    public class DeadLockDemo {
        private static final String A = "A";
        private static final String B = "B";
    
        private static void deadLock(){
            Thread thread1 = new Thread(() -> {
                synchronized (A){
                    try {
                        Thread.sleep(2000);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                    synchronized (B){
                        System.out.println("1");
                    }
                }
            });
    
            Thread thread2 = new Thread(() -> {
                synchronized (B){
                    try {
                        Thread.sleep(2000);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                    synchronized (A){
                        System.out.println("2");
                    }
                }
            });
            thread1.start();
            thread2.start();
        }
    
        public static void main(String[] args) {
            DeadLockDemo.deadLock();
        }
    }