Java基础-多线程（线程同步、线程锁、死锁）

什么是线程？

在了解线程之前，首先要知道什么是进程。首先，进程是一个动态的过程，是一个活动的实体。简单来说，一个应用程序的运行就可以被看做是一个进程，而线程，是运行中的实际的任务执行者。可以说，进程中包含了多个可以同时运行的线程。

创建多线程的三种方式

方式一：继承Thread类，重写run方法

// 设置线程名称
public ThreadClass(String name) {
    super(name);
}

@Override
public void run() {
    // TODO Auto-generated method stub
    for (int i = 0; i < 5; i++) {
        System.out.println("线程名：" + this.currentThread().getName() + "执行第" + i + "次！");
    }
}

public static void main(String[] args) {
    //创建两个线程
    ThreadClass thread1 = new ThreadClass("thread1");
    ThreadClass thread2 = new ThreadClass("thread2");

    //执行
    thread1.start();
    thread2.start();
}

方式二：

public class ThreadClass implements Runnable {

	@Override
	public void run() {
		// TODO Auto-generated method stub
		for (int i = 0; i < 5; i++) {
			System.out.println("线程名：" + Thread.currentThread().getName() + "执行第" + i + "次！");
		}
	}

	public static void main(String[] args) {
		// 创建两个线程
		ThreadClass thread = new ThreadClass();
		Thread thread1 = new Thread(thread);
		Thread thread2 = new Thread(thread);

		//执行
		thread1.start();
		thread2.start();
	}
}

方式三：实现Callable接口

public class ThreadClass implements Callable<Integer> {

	@Override
	public Integer call() throws Exception {
		// TODO Auto-generated method stub
		int i = 0;
		for(;i<5;i++) {
			System.out.println("线程名："+Thread.currentThread().getName()+"执行第"+i+"次！");
		}
		return 1;
	}

	public static void main(String[] args) {
		ThreadClass tc = new ThreadClass();	//创建对象
		FutureTask<Integer> ft = new FutureTask<Integer>(tc);	//使用FutureTask包装。
		
		for (int i = 0; i < 5; i++) {
			System.out.println("主线程："+Thread.currentThread().getName()+"执行第"+i+"次！");
			
			if(i == 2) {
				Thread thread1 = new Thread(ft,"子线程");
				thread1.start();
			}
		}
		
		//获取子线程call方法的返回值
		try {
			System.out.println(ft.get());
		} catch (InterruptedException | ExecutionException e) {
			e.printStackTrace();
		}
		
	}
}

线程的生命周期

• 新建状态：new Thread();
• 就绪状态：当处理新建状态的线程调用start()方法后就拥有了争抢CPU的资格，但是并未运行，这就是就绪状态。
• 运行状态：当处于就绪状态的线程获取到CPU的使用权时就进入运行状态。
• 阻塞状态：当处于运行状态的线程因为某种原因暂时放弃CPU的使用权，停止执行，此时线程进入阻塞状态，当阻塞状态结束时，进入就绪状态。
• 死亡状态：当程序正常结束或者异常退出时，线程进入死亡状态。

线程的调度

线程休眠（sleep）

线程休眠是指让线程由运行中状态进入不可运行状态，休眠时间过后进入可运行状态。sleep和wait的区别在于sleep不会释放锁，而wait会释放锁。

示例：

public class ThreadClass {

	public static void sleepByte(long s) {
		for (int i = 0; i < s; i++) {
			try {
				Thread.sleep(1000);
				System.out.println(Thread.currentThread().getName() +"休眠"+(i+1)+"秒!");
			} catch (InterruptedException e) {
				// TODO Auto-generated catch block
				e.printStackTrace();
			}
		}
	}

	public static void main(String[] args) throws InterruptedException {
		ThreadClass.sleepByte(5);
		System.out.println("start...");
	}

}

线程礼让（yield）

yield()是将运行中的线程进入不可运行状态，重回就绪状态。重新和其他线程争抢CPU资源。

public class OneThread implements Runnable{

	@Override
	public void run() {
		// TODO Auto-generated method stub
		 for (int i = 0; i < 5; i++) {
	            System.out.println("第一个线程的第" + (i + 1) + "次运行-" + Thread.currentThread().getName());
	            // 暂停线程
	            Thread.yield();
	        }
	}

}

public class TwoThread implements Runnable{

	@Override
	public void run() {
		// TODO Auto-generated method stub
		 for (int i = 0; i < 5; i++) {
	            System.out.println("第二个线程的第" + (i + 1) + "次运行-" + Thread.currentThread().getName());
	            // 暂停线程
	            Thread.yield();
	        }
	}

}

public class Demo {

	public static void main(String[] args) {
		OneThread ot = new OneThread();
		TwoThread tt = new TwoThread();
		Thread oneThread = new Thread(ot);
		Thread twoThread = new Thread(tt);
		oneThread.start();
		twoThread.start();
	}

}

线程强制执行（join）

当到达指定条件时，当前线程会停止，待调用join方法的线程执行完毕时再继续执行当前线程。

public class ThreadClass implements Runnable{

	@Override
	public void run() {
		// TODO Auto-generated method stub
		 for (int i = 0; i < 5; i++) {
	            System.out.println("子线程"+Thread.currentThread().getName()+"-"+(i+1));
	        }
	}
	
	public static void main(String[] args) throws InterruptedException {
		for (int i = 0; i < 10; i++) {
			//当i等于1时执行子线程
			if(i==1) {
				ThreadClass tc= new ThreadClass();
				Thread thread = new Thread(tc);
				thread.start();
				thread.join();
			}
			System.out.println("主线程"+Thread.currentThread().getName()+"-"+(i+1));
		}
	}

}

线程同步（wait/notify/notifyAll）

wait( )，notify( )，notifyAll( )都不属于Thread类，而是属于Object基础类，也就是每个对象都有wait( )，notify( )，notifyAll( ) 的功能，因为每个对象都有锁，锁是每个对象的基础，当然操作锁的方法也是最基础了。

void notify()
Wakes up a single thread that is waiting on this object’s monitor.
译：唤醒在此对象监视器上等待的单个线程

void notifyAll()
Wakes up all threads that are waiting on this object’s monitor.
译：唤醒在此对象监视器上等待的所有线程

void wait( )
Causes the current thread to wait until another thread invokes the notify() method or the notifyAll( ) method for this object.
译：导致当前的线程等待，直到其他线程调用此对象的notify( ) 方法或 notifyAll( ) 方法

void wait(long timeout)
Causes the current thread to wait until either another thread invokes the notify( ) method or the notifyAll( ) method for this object, or a specified amount of time has elapsed.
译：导致当前的线程等待，直到其他线程调用此对象的notify() 方法或 notifyAll() 方法，或者指定的时间过完。

void wait(long timeout, int nanos)
Causes the current thread to wait until another thread invokes the notify( ) method or the notifyAll( ) method for this object, or some other thread interrupts the current thread, or a certain amount of real time has elapsed.
译：导致当前的线程等待，直到其他线程调用此对象的notify( ) 方法或 notifyAll( ) 方法，或者其他线程打断了当前线程，或者指定的时间过完。

• 当需要调用以上的方法的时候，一定要对竞争资源进行加锁，如果不加锁的话，则会报 IllegalMonitorStateException 异常
• 当想要调用wait( )进行线程等待时，必须要取得这个锁对象的控制权（对象监视器），一般是放到synchronized(obj)代码中。
• 在while循环里而不是if语句下使用wait，这样，会在线程暂停恢复后都检查wait的条件，并在条件实际上并未改变的情况下处理唤醒通知
• 调用obj.wait( )释放了obj的锁，否则其他线程也无法获得obj的锁，也就无法在synchronized(obj){ obj.notify() } 代码段内唤醒A。
• notify( )方法只会通知等待队列中的某一个相关线程，而具体是哪个线程由JVM随机决定（不会通知优先级比较高的线程）。
• notifyAll( )通知所有等待该竞争资源的线程（也不会按照线程的优先级来执行）
• 假设有三个线程执行了obj.wait( )，那么obj.notifyAll( )则能全部唤醒tread1，thread2，thread3，但是要继续执行obj.wait（）的下一条语句，必须获得obj锁，因此，tread1，thread2，thread3只有一个有机会获得锁继续执行，例如tread1，其余的需要等待thread1释放obj锁之后才能继续执行。
• 当调用obj.notify/notifyAll后，调用线程依旧持有obj锁，因此，thread1，thread2，thread3虽被唤醒，但是仍无法获得obj锁。直到调用线程退出synchronized块，释放obj锁后，thread1，thread2，thread3中的一个才有机会获得锁继续执行。

示例代码

public class WaitNotifyTest {

	// 在多线程间共享的对象上使用wait
	private String[] shareObj = { "true" };

	public static void main(String[] args) {
		WaitNotifyTest test = new WaitNotifyTest();
		ThreadWait threadWait1 = test.new ThreadWait("wait thread1");
		threadWait1.setPriority(2);
		ThreadWait threadWait2 = test.new ThreadWait("wait thread2");
		threadWait2.setPriority(3);
		ThreadWait threadWait3 = test.new ThreadWait("wait thread3");
		threadWait3.setPriority(4);

		ThreadNotify threadNotify = test.new ThreadNotify("notify thread");

		threadNotify.start();
		threadWait1.start();
		threadWait2.start();
		threadWait3.start();
	}

	class ThreadWait extends Thread {

		public ThreadWait(String name) {
			super(name);
		}

		public void run() {
			synchronized (shareObj) {
				while ("true".equals(shareObj[0])) {
					System.out.println("线程" + this.getName() + "开始等待");
					long startTime = System.currentTimeMillis();
					try {
						shareObj.wait();
					} catch (InterruptedException e) {
						e.printStackTrace();
					}
					long endTime = System.currentTimeMillis();
					System.out.println("线程" + this.getName() + "等待时间为：" + (endTime - startTime));
				}
			}
			System.out.println("线程" + getName() + "等待结束");
		}
	}

	class ThreadNotify extends Thread {

		public ThreadNotify(String name) {
			super(name);
		}

		public void run() {
			try {
				// 给等待线程等待时间
				sleep(3001);
			} catch (InterruptedException e) {
				e.printStackTrace();
			}
			synchronized (shareObj) {
				System.out.println("线程" + this.getName() + "开始准备通知");
				shareObj[0] = "false";
				shareObj.notifyAll();
				System.out.println("线程" + this.getName() + "通知结束");
			}
			System.out.println("线程" + this.getName() + "运行结束");
		}
	}
}

wait/notify/notifyAll文章来自 https://blog.csdn.net/jianiuqi/article/details/53448849

线程同步（synchronized）

synchronized的作用

当多个线程同时操作一个全局变量时，在修改或写入时会导致数据的不一致性。而synchronized的作用就像一把锁。当synchronized锁住一个对象后，别的线程如果也想拿到这个对象的锁，就必须等待这个线程执行完成释放锁，才能再次给对象加锁，这样才就可以达到线程同步的目的，保证数据的可见性。

现在有两个售票窗口，同时卖10张票。

public class ThreadClass implements Runnable{
	
	//总共10张票
	private int count = 10;

	@Override
	public void run() {

		for (int i = 0; i < 5; i++) {
			try {
				Thread.sleep(1000);
			} catch (InterruptedException e) {
				// TODO Auto-generated catch block
				e.printStackTrace();
			}
			sale();
		}
	}
	
	public void sale() {
			if(count>0) {
				System.out.println(Thread.currentThread().getName() + ",售出第" + (10 - count + 1) + "张票");
                count--;
			}
	}
	
	public static void main(String[] args) throws InterruptedException {
		ThreadClass tc = new ThreadClass();
		Thread thread1 = new Thread(tc,"1号窗口");
		Thread thread2 = new Thread(tc,"2号窗口");
		thread1.start();
		thread2.start();
	}
}

运行结果如下：

**分析：**在线程不同步的情况下，两个窗口都售出了同一张车票。

*结论发现，多个线程共享同一个全局成员变量时，操作可能会发生数据冲突问题。*

修饰代码块

一个线程访问一个对象中的synchronized(this)同步代码块时，其他试图访问该对象的线程将被阻塞

public class ThreadClass implements Runnable{
	
	//总共10张票
	private int count = 10;

	@Override
	public void run() {

		for (int i = 0; i < 5; i++) {
			try {
				Thread.sleep(1000);
			} catch (InterruptedException e) {
				// TODO Auto-generated catch block
				e.printStackTrace();
			}
			sale();
		}
	}
	
	public void sale() {
        修饰代码块
		synchronized(this) {
			if(count>0) {
				System.out.println(Thread.currentThread().getName() + ",售出第" + (10 - count + 1) + "张票");
                count--;
			}
		}
	}
	
	public static void main(String[] args) throws InterruptedException {
		ThreadClass tc = new ThreadClass();
		Thread thread1 = new Thread(tc,"1号窗口");
		Thread thread2 = new Thread(tc,"2号窗口");
		thread1.start();
		thread2.start();
	}
}

修饰方法

Synchronized修饰一个方法很简单，就是在方法的前面加synchronized，synchronized修饰方法和修饰一个代码块类似，只是作用范围不一样，修饰代码块是大括号括起来的范围，而修饰方法范围是整个函数。

public class ThreadClass implements Runnable {
	// 总共10张票
	private int count = 10;

	@Override
	public void run() {

		for (int i = 0; i < 5; i++) {
			try {
				Thread.sleep(1000);
			} catch (InterruptedException e) {
				// TODO Auto-generated catch block
				e.printStackTrace();
			}
			sale();
		}
	}
	//修饰方法
	public synchronized void sale() {
		if (count > 0) {
			System.out.println(Thread.currentThread().getName() + ",售出第" + (10 - count + 1) + "张票");
			count--;
		}
	}

	public static void main(String[] args) throws InterruptedException {
		ThreadClass tc = new ThreadClass();
		Thread thread1 = new Thread(tc, "1号窗口");
		Thread thread2 = new Thread(tc, "2号窗口");
		thread1.start();
		thread2.start();
	}
}

修饰静态方法

tc1和tc2是ThreadClass的两个对象，但是thread1和thread2并行时却实现了同步。这是因为当run方法中调用了使用synchronized修饰的静态方法，而静态方法是属于类的，所以thread1和thread2相当于使用了同一把锁

public class ThreadClass implements Runnable {
	// 总共10张票
	private static int count = 10;

	@Override
	public void run() {

		for (int i = 0; i < 5; i++) {
			try {
				Thread.sleep(1000);
			} catch (InterruptedException e) {
				// TODO Auto-generated catch block
				e.printStackTrace();
			}
			sale();
		}
	}
	//修饰静态方法。
	public synchronized static void sale() {
		if (count > 0) {
			System.out.println(Thread.currentThread().getName() + ",售出第" + (10 - count + 1) + "张票");
			count--;
		}
	}

	public static void main(String[] args) throws InterruptedException {
		ThreadClass tc1 = new ThreadClass();
		ThreadClass tc2 = new ThreadClass();
		Thread thread1 = new Thread(tc1, "1号窗口");
		Thread thread2 = new Thread(tc2, "2号窗口");
		thread1.start();
		thread2.start();
	}
}

修饰类

public class ThreadClass implements Runnable {
	
	// 总共10张票
	private int count = 10;

	@Override
	public void run() {

		for (int i = 0; i < 5; i++) {
			try {
				Thread.sleep(1000);
			} catch (InterruptedException e) {
				// TODO Auto-generated catch block
				e.printStackTrace();
			}
			sale();
		}
	}

	public void sale() {
        //修饰类：类名.class
		synchronized(ThreadClass.class) {
			if (count > 0) {
				System.out.println(Thread.currentThread().getName() + ",售出第" + (10 - count + 1) + "张票");
				count--;
			}
		}
	}

	public static void main(String[] args) throws InterruptedException {
		ThreadClass tc = new ThreadClass();
		Thread thread1 = new Thread(tc, "1号窗口");
		Thread thread2 = new Thread(tc, "2号窗口");
		thread1.start();
		thread2.start();
	}
}

如果是两个对象需要保证同步的情况,必须要保证方法为静态方法，否则不能保证同步性。
例如：ThreadClass tc1 = new ThreadClass();
ThreadClass tc2 = new ThreadClass();

public class ThreadClass implements Runnable {
	
	// 总共10张票
	private static int count = 10;

	@Override
	public void run() {

		for (int i = 0; i < 5; i++) {
			try {
				Thread.sleep(1000);
			} catch (InterruptedException e) {
				// TODO Auto-generated catch block
				e.printStackTrace();
			}
			sale();
		}
	}

	public static void sale() {
		synchronized(ThreadClass.class) {
			if (count > 0) {
				System.out.println(Thread.currentThread().getName() + ",售出第" + (10 - count + 1) + "张票");
				count--;
			}
		}
	}
	
	//如果是两个对象需要保证同步的情况,必须要保证方法为静态方法，否则不能保证同步性。
	public static void main(String[] args) throws InterruptedException {
		ThreadClass tc1 = new ThreadClass();
		ThreadClass tc2 = new ThreadClass();
		Thread thread1 = new Thread(tc1, "1号窗口");
		Thread thread2 = new Thread(tc2, "2号窗口");
		thread1.start();
		thread2.start();
	}
}

线程同步（Lock）

Lock是Java中的一个接口，它位于util.concurrent.locks包内。Lock类中有5个方法，下面一起来看一下JDK源码。

public interface Lock {

    /**
     * Acquires the lock.
     * 获取锁
     */
    void lock();

    /**
     * Acquires the lock unless the current thread is
     * {@linkplain Thread#interrupt interrupted}.
     * 获取锁，除非当前线程被线程中断
     */
    void lockInterruptibly() throws InterruptedException;

    /**
     * Acquires the lock only if it is free at the time of invocation.
     * 只有在调用时锁是空闲的情况下才获取锁。
     */
    boolean tryLock();

    /**
     * Acquires the lock if it is free within the given waiting time and the
     * current thread has not been {@linkplain Thread#interrupt interrupted}.
     * 如果在给定的等待时间内锁是空闲的，并且当前线程没有被线程中断，则获取锁
     */
    boolean tryLock(long time, TimeUnit unit) throws InterruptedException;

    /**
     * Releases the lock.
     * 释放锁
     */
    void unlock();
	
}

ReentrantLock

ReentrantLock是Lock唯一的实现类。

示例代码（lock()/unLock()）

在lock()获取锁后必须在finally{}中调用unLock()释放锁，否则很容易造成死锁。

public class LockTest {

	//ReentrantLock是Lock接口的实现类。
	private Lock lock = new ReentrantLock();
	
	private void method(Thread thread) {
		
		
		lock.lock();//	获取锁
		try {
			System.out.println("线程名"+thread.getName()+"获取了锁!");
			
		} catch (Exception e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		} finally {
			System.out.println("线程名"+thread.getName()+"释放了锁!");
			lock.unlock();// 释放锁
		}
		
	}
	
	public static void main(String[] args) {
		LockTest lt = new LockTest();
		
		//线程1
		Thread thread1 = new Thread(new Runnable() {
			
			@Override
			public void run() {
				// TODO Auto-generated method stub
				lt.method(Thread.currentThread());
			}
		},"thread1");
		
		//线程2
		Thread thread2 = new Thread(new Runnable() {
			
			@Override
			public void run() {
				// TODO Auto-generated method stub
				lt.method(Thread.currentThread());
			}
		},"thread2");
		
		thread1.start(); 
		thread2.start();
	}
	
	//运行结果
	//	线程名thread1获取了锁!
	//	线程名thread1释放了锁!
	//	线程名thread2获取了锁!
	//	线程名thread2释放了锁!
}

示例代码（tryLock()）

tryLock()表示用来尝试获取锁，如果获取成功，则返回true，如果获取失败（即锁已被其他线程获取），则返回false，

public class LockTest {

	//ReentrantLock是Lock接口的实现类。
	private Lock lock = new ReentrantLock();
	
	private void method(Thread thread) {
		
		if(lock.tryLock()) {
			lock.lock();//	获取锁
			try {
				System.out.println("线程名"+thread.getName()+"获取了锁!");
				
			} catch (Exception e) {
				// TODO Auto-generated catch block
				e.printStackTrace();
			} finally {
				System.out.println("线程名"+thread.getName()+"释放了锁!");
				lock.unlock();// 释放锁
			}
		}else {
			System.out.println("我是"+thread.getName()+"，有人占着锁，我就不要啦！");
		}
	}
	
	public static void main(String[] args) {
		LockTest lt = new LockTest();
		
		//线程1
		Thread thread1 = new Thread(new Runnable() {
			
			@Override
			public void run() {
				// TODO Auto-generated method stub
				lt.method(Thread.currentThread());
			}
		},"thread1");
		
		//线程2
		Thread thread2 = new Thread(new Runnable() {
			
			@Override
			public void run() {
				// TODO Auto-generated method stub
				lt.method(Thread.currentThread());
			}
		},"thread2");
		
		thread1.start(); 
		thread2.start();
	}
	
	//运行结果
	//	线程名thread1获取了锁!
	//	我是thread2，有人占着锁，我就不要啦！
	//	线程名thread1释放了锁!

}

tryLock(long time, TimeUnit unit)方法和tryLock()方法是类似的，只不过区别在于这个方法在拿不到锁时会等待一定的时间，在时间期限之内如果还拿不到锁，就返回false。如果如果一开始拿到锁或者在等待期间内拿到了锁，则返回true。

lockInterruptibly

lockInterruptibly也是获取锁的一种方式，但是当通过这个方法去获取锁时，如果线程正在等待获取锁，则这个线程能够响应中断，即中断线程的等待状态。也就使说，当两个线程同时通过lock.lockInterruptibly()想获取某个锁时，假若此时线程A获取到了锁，而线程B只有在等待，那么对线程B调用threadB.interrupt()方法能够中断线程B的等待过程。

线程同步（ReadWriteLock）

ReadWtiteLock（读写锁）也是一个接口，接口里定义了两个方法。一个用来获取读锁，一个用来获取写锁。也就是说将文件的读写操作分开，分成2个锁来分配给线程，从而使得多个线程可以同时进行读操作。

ReentrantReadWriteLock

ReentrantReadWriteLock是ReadWriteLock的实现类。里面提供了很多丰富的方法，不过最主要的有两个方法：readLock()和writeLock()用来获取读锁和写锁。下面通过几个例子来看一下ReentrantReadWriteLock具体用法。

假设有多个线程要同时进行读操作：

使用synchronized示例

public class LockTest {

	private synchronized void method(Thread thread) {
		
		long start = System.currentTimeMillis();
		while(System.currentTimeMillis() - start <= 1) {
			System.out.println(thread.getName() +"正在进行读操作！");
		}
		System.out.println(thread.getName()+"读操作进行完毕！");
	}

	public static void main(String[] args) {
		LockTest lt = new LockTest();
		
		//线程1
		Thread thread1 = new Thread(new Runnable() {
			
			@Override
			public void run() {
				// TODO Auto-generated method stub
				lt.method(Thread.currentThread());
			}
		},"thread1");
		
		//线程2
		Thread thread2 = new Thread(new Runnable() {
			
			@Override
			public void run() {
				// TODO Auto-generated method stub
				lt.method(Thread.currentThread());
			}
		},"thread2");
		
		thread1.start();
		thread2.start();
	}
}

使用ReentrantReadWriteLock示例

public class LockTest {

	//读写锁
	private ReentrantReadWriteLock rrwl = new ReentrantReadWriteLock();
	
	private void method(Thread thread) {
		
		rrwl.readLock().lock();	//获取读锁
		try {
			long start = System.currentTimeMillis();
			while(System.currentTimeMillis() - start <= 1) {
				System.out.println(thread.getName() +"正在进行读操作！");
			}
			System.out.println(thread.getName()+"读操作进行完毕！");
		} catch (Exception e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		} finally {
			rrwl.readLock().unlock();//释放读锁
		}
	}

	public static void main(String[] args) {
		LockTest lt = new LockTest();
		
		//线程1
		Thread thread1 = new Thread(new Runnable() {
			
			@Override
			public void run() {
				// TODO Auto-generated method stub
				lt.method(Thread.currentThread());
			}
		},"thread1");
		
		//线程2
		Thread thread2 = new Thread(new Runnable() {
			
			@Override
			public void run() {
				// TODO Auto-generated method stub
				lt.method(Thread.currentThread());
			}
		},"thread2");
		
		thread1.start();
		thread2.start();
	}
}

由打印结果可以看出，thread1和thread2同时在做读取操作，这样就大大的提升了读操作的效率。

需要注意的是，如果一个线程已经占用了读锁，而现在另一个线程需要申请写锁，则申请的线程就会一直等待读锁释放。如果一个线程已经占用了写锁，而另一个线程申请读锁或者写锁，则申请的线程就会一直等待写锁释放

Synchronized和Lock比较

• Lock是一个接口，而synchronized是Java中的关键字，synchronized是内置的语言实现；
• synchronized在发生异常时，会自动释放线程占有的锁，因此不会导致死锁现象发生；而Lock在发生异常时，如果没有主动通过unLock()去释放锁，则很可能造成死锁现象，因此使用Lock时需要在finally块中释放锁；
• Lock可以让等待锁的线程响应中断，而synchronized却不行，使用synchronized时，等待的线程会一直等待下去，不能够响应中断；
• 通过Lock可以知道有没有成功获取锁，而synchronized却无法办到。
• Lock可以提高多个线程进行读操作的效率。

线程死锁

多线程以及多进程改善了系统资源的利用率并提高了系统 的处理能力。然而，并发执行也带来了新的问题——死锁。所谓死锁是指多个线程因竞争资源而造成的一种僵局（互相等待），若无外力作用，这些进程都将无法向前推进。

**生活中的例子：**2个人一起吃饭但是只有一双筷子，2人轮流吃（同时拥有2只筷子才能吃）。某一个时候，一个拿了左筷子，一人拿了右筷子，2个人都同时占用一个资源，等待另一个资源，这个时候甲在等待乙吃完并释放它占有的筷子，同理，乙也在等待甲吃完并释放它占有的筷子，这样就陷入了一个死循环，谁也无法继续吃饭。。。

示例代码：

/** 
* 	一个简单的死锁类 
* 	当RunnableClass类的对象flag==1时（rc1），先锁定obj1,睡眠500毫秒 
* 	而rc1在睡眠的时候另一个flag==0的对象（rc2）线程启动，先锁定obj2,睡眠500毫秒 
*	rc1睡眠结束后需要锁定obj2才能继续执行，而此时obj2已被rc2锁定； 
* 	rc2睡眠结束后需要锁定obj1才能继续执行，而此时obj1已被rc1锁定； 
* 	rc1、rc2相互等待，都需要得到对方锁定的资源才能继续执行，从而死锁。 
*/
public class RunnableClass implements Runnable{
	
	private int flag = 1;
	private static Object obj1 = new Object(),obj2 = new Object();
	

	@Override
	public void run() {
		if(flag == 1) {
			synchronized(obj1) {
				try {
					Thread.sleep(500);
				} catch (InterruptedException e) {
					// TODO Auto-generated catch block
					e.printStackTrace();
				}
				
				synchronized(obj2) {
					System.out.println("1");
				}
			}
		}
		
		if(flag == 0) {
			synchronized(obj2) {
				try {
					Thread.sleep(500);
				} catch (InterruptedException e) {
					// TODO Auto-generated catch block
					e.printStackTrace();
				}
				
				synchronized(obj1) {
					System.out.println("0");
				}
			}
		}
	}
	
	public static void main(String[] args) {
		RunnableClass rc1 = new RunnableClass();
		RunnableClass rc2 = new RunnableClass();
		rc1.flag = 1;
		rc2.flag = 0;
		new Thread(rc1).start();
		new Thread(rc2).start();
	}

}

文尾

文章均为学习阶段记录笔记，若有不妥请留言指正。谢谢！