Java线程同步与锁

- 日理万妓 2022-07-14 00:23 363阅读 0赞

**一、多线程同步**

当AB两个线程同时竞争资源时，A线程先获取到资源执行，B线程处于阻塞状态，A线程释放资源后，B线程从挂起处继续执行。

测试代码：

public class WaitNotifyDemo {
    
    	public class PrinterA implements Runnable {
    		@Override
    		public void run() {
    			System.out.println("A start");
    			synchronized (WaitNotifyDemo.this) {
    				System.out.println("A begin " + System.currentTimeMillis());
    				try {
    					Thread.sleep(10 * 1000);
    				} catch (InterruptedException e) {
    					e.printStackTrace();
    				}
    				System.out.println("A end " + System.currentTimeMillis());
    			}
    		}
    	}
    	
    	public class PrinterB implements Runnable {
    
    		@Override
    		public void run() {
    			System.out.println("B start");
    			synchronized (WaitNotifyDemo.this) {
    				System.out.println("B begin " + System.currentTimeMillis());
    				try {
    					Thread.sleep(10 * 1000);
    				} catch (InterruptedException e) {
    					e.printStackTrace();
    				}
    				System.out.println("B end " + System.currentTimeMillis());
    			}
    		}
    	}
    	
    	public static void main(String[] args) {
    		WaitNotifyDemo demo = new WaitNotifyDemo();
    		demo.doPrint();
    	}
    
    	private void doPrint() {
    		PrinterA pa = new PrinterA();
    		PrinterB pb = new PrinterB();
    		Thread a = new Thread(pa);
    		Thread b = new Thread(pb);
    		a.start();
    		b.start();
    	}
    }

输出结果：

A start
    B start
    A begin 1479709224158
    A end 1479709234158
    B begin 1479709234158
    B end 1479709244159

看出AB线程start后，都各自输出自己的“start”，因为A线程先开始，所以先获取到资源，然后A线程调用sleep方法休眠10秒，此时B线程处于阻塞状态。10秒后A线程释放锁，B线程进入锁，继续执行下去。

**二、多线程锁**

需求：A线程打印123，B线程打印456，然后A线程再打印789

这时候需要线程锁来达到线程间交互。

首先B线程使用wait()方法挂起，A线程打印132并且使用notify()方法唤醒B线程，A线程自身挂起，B线程开始打印465然后使用notify()方法唤醒A线程，B线程自身挂起。

注意无论是wait，还是notify，notifyAll方法都需要在其实例对象的同步块中执行，这样当前线程才能获得同步实例的同步控制权，如果不在同步块中执行wait或者notify方法会出现java.lang.IllegalMonitorStateException异常。

测试代码：

public class WaitNotifyDemo {
    	private volatile int val = 1;
    
    	private synchronized void printAndIncrease() {
    		System.out.println(Thread.currentThread().getName() + " prints " + val);
    		val++;
    	}
    
    	// print 1,2,3 7,8,9
    	public class PrinterA implements Runnable {
    		@Override
    		public void run() {
    			while (val <= 3) {
    				printAndIncrease();
    			}
    
    			// print 1,2,3 then notify printerB
    			synchronized (WaitNotifyDemo.this) {
    				System.out.println("PrinterA printed 1,2,3; notify PrinterB");
    				WaitNotifyDemo.this.notify();
    			}
    
    			try {
    				while (val <= 6) {
    					synchronized (WaitNotifyDemo.this) {
    						System.out.println("wait in printerA");
    						WaitNotifyDemo.this.wait();
    					}
    				}
    				System.out.println("wait end printerA");
    			} catch (InterruptedException e) {
    				e.printStackTrace();
    			}
    			while (val <= 9) {
    				printAndIncrease();
    			}
    			System.out.println("PrinterA exits");
    		}
    	}
    	// print 4,5,6 after printA print 1,2,3
    	public class PrinterB implements Runnable {
    
    		@Override
    		public void run() {
    			while (val < 3) {
    				synchronized (WaitNotifyDemo.this) {
    					try {
    						System.out
    								.println("printerB wait for printerA printed 1,2,3");
    						WaitNotifyDemo.this.wait();
    						System.out
    								.println("printerB waited for printerA printed 1,2,3");
    					} catch (InterruptedException e) {
    						e.printStackTrace();
    					}
    				}
    			}
    			while (val <= 6) {
    				printAndIncrease();
    			}
    
    			System.out.println("notify in printerB");
    			synchronized (WaitNotifyDemo.this) {
    				WaitNotifyDemo.this.notify();
    			}
    			System.out.println("notify end printerB");
    			System.out.println("PrinterB exits.");
    		}
    	}
    	public static void main(String[] args) {
    		WaitNotifyDemo demo = new WaitNotifyDemo();
    		demo.doPrint();
    	}
    
    	private void doPrint() {
    		PrinterA pa = new PrinterA();
    		PrinterB pb = new PrinterB();
    		Thread a = new Thread(pa);
    		a.setName("printerA");
    		Thread b = new Thread(pb);
    		b.setName("printerB");
    		// 必须让b线程先执行，否则b线程有可能得不到锁，执行不了wait，而a线程一直持有锁，会先notify了
    		b.start();
    		a.start();
    	}
    }

输出结果：

printerB wait for printerA printed 1,2,3
    printerA prints 1
    printerA prints 2
    printerA prints 3
    PrinterA printed 1,2,3; notify PrinterB
    printerB waited for printerA printed 1,2,3
    printerB prints 4
    printerB prints 5
    printerB prints 6
    notify in printerB
    notify end printerB
    PrinterB exits.
    wait end printerA
    printerA prints 7
    printerA prints 8
    printerA prints 9
    PrinterA exits

参考：

[http://outofmemory.cn/java/java.util.concurrent/thread-sync-with-object-wait-notify-notifyAll][http_outofmemory.cn_java_java.util.concurrent_thread-sync-with-object-wait-notify-notifyAll]

[http_outofmemory.cn_java_java.util.concurrent_thread-sync-with-object-wait-notify-notifyAll]: http://outofmemory.cn/java/java.util.concurrent/thread-sync-with-object-wait-notify-notifyAll