1、synchronized

synchronized表示当前线程，独占 对象 someObject
当前线程独占 了对象someObject，如果有其他线程试图占有对象someObject，就会等待，直到当前线程释放对someObject的占用。
someObject 又叫同步对象，所有的对象，都可以作为同步对象
为了达到同步的效果，必须使用同一个同步对象
释放同步对象的方式： synchronized 块自然结束，或者有异常抛出

package MultiThread;import java.text.SimpleDateFormat;
import java.util.Date;public class TestThread3 {public static String now() {return new SimpleDateFormat("HH:mm:ss").format(new Date());}public static void main(String[] args) {final Object someObj = new Object();Thread t1 = new Thread () {public void run() {try {System.out.println( now()+" t1 线程已经运行");System.out.println( now()+this.getName()+ " 试图占有对象：someObject");synchronized (someObj) {System.out.println( now()+this.getName()+ " 占有对象：someObject");Thread.sleep(5000);System.out.println( now()+this.getName()+ " 释放对象：someObject");}System.out.println(now()+" t1 线程结束");} catch (Exception e) {// TODO: handle exceptione.printStackTrace();}}};t1.setName("  t1");t1.start();Thread t2 = new Thread () {public void run() {try {System.out.println( now()+" t2 线程已经运行");System.out.println( now()+this.getName()+ " 试图占有对象：someObject");synchronized (someObj) {System.out.println( now()+this.getName()+ " 占有对象：someObject");Thread.sleep(5000);System.out.println( now()+this.getName()+ " 释放对象：someObject");}System.out.println(now()+" t2 线程结束");} catch (Exception e) {// TODO: handle exceptione.printStackTrace();}}};t2.setName("  t2");t2.start();}
}

2、线程死锁

（1） 线程1 首先占有对象1，接着试图占有对象2

（2）线程2 首先占有对象2，接着试图占有对象1

（3）线程1 等待线程2释放对象2

（4）与此同时，线程2等待线程1释放对象1

就会。。。一直等待下去，直到天荒地老

3、Lock

Lock是一个接口

与 synchronized (someObject) 类似的，lock()方法，表示当前线程占用lock对象，一旦占用，其他线程就不能占用了。
与 synchronized 不同的是，一旦synchronized 块结束，就会自动释放对someObject的占用。 lock却必须调用unlock方法进行手动释放，为了保证释放的执行，往往会把unlock() 放在finally中进行

package MultiThread;import java.text.SimpleDateFormat;
import java.util.Date;
import java.util.concurrent.locks.Condition;
import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;public class TestLock {/*与 synchronized (someObject) 类似的，lock()方法，表示当前线程占用lock对象，一旦占用，其他线程就不能占用了。与 synchronized 不同的是，一旦synchronized 块结束，就会自动释放对someObject的占用。 lock却必须调用unlock方法进行手动释放，为了保证释放的执行，往往会把unlock() 放在finally中进行。* *//* 1. Lock是一个接口，而synchronized是Java中的关键字，synchronized是内置的语言实现，Lock是代码层面的实现。2. Lock可以选择性的获取锁，如果一段时间获取不到，可以放弃。synchronized不行，会一根筋一直获取下去。 借助Lock的这个特性，就能够规避死锁，synchronized必须通过谨慎和良好的设计，才能减少死锁的发生。3. synchronized在发生异常和同步块结束的时候，会自动释放锁。而Lock必须手动释放， 所以如果忘记了释放锁，一样会造成死锁* */public static void main(String[] args) {Lock lock = new ReentrantLock();Condition condition = lock.newCondition();/* 使用synchronized方式进行线程交互，用到的是同步对象的wait,notify和notifyAll方法Lock也提供了类似的解决办法，首先通过lock对象得到一个Condition对象，然后分别调用这个Condition对象的：await, signal,signalAll 方法*/Thread t1 = new Thread() {public void run() {try {log("线程启动");log("试图占有对象：lock");lock.lock();log("占有对象：lock");log("进行5秒的业务操作");Thread.sleep(5000);log("临时释放对象 lock， 并等待");condition.await();log("重新占有对象 lock，并进行5秒的业务操作");Thread.sleep(5000);} catch (InterruptedException e) {// TODO: handle exceptione.printStackTrace();} finally {log("释放对象：lock");lock.unlock();}log("线程结束");}};t1.setName("t1");t1.start();try {//先让t1飞2秒Thread.sleep(2000);} catch (InterruptedException e1) {// TODO Auto-generated catch blocke1.printStackTrace();}Thread t2 = new Thread () {public void run() {try {log("线程启动");log("试图占有对象：lock");lock.lock();log("占有对象：lock");log("进行5秒的业务操作");Thread.sleep(5000);log("唤醒等待中的线程");condition.signal();} catch (InterruptedException e) {// TODO: handle exceptione.printStackTrace();} finally {log("释放对象：lock");lock.unlock();}log("线程结束");}};t2.setName("t2");t2.start();}public static String now() {return new SimpleDateFormat("HH:mm:ss").format(new Date());}public static void log(String msg) {System.out.printf("%s -- %s %s %n", now() , Thread.currentThread().getName() , msg);}
}

总结Lock和synchronized的区别

1、Lock是一个接口，而synchronized是Java中的关键字，synchronized是内置的语言实现，Lock是代码层面的实现。
2、 Lock可以选择性的获取锁，如果一段时间获取不到，可以放弃。synchronized不行，会一根筋一直获取下去。 借助Lock的这个特性，就能够规避死锁，synchronized必须通过谨慎和良好的设计，才能减少死锁的发生。
3、 synchronized在发生异常和同步块结束的时候，会自动释放锁。而Lock必须手动释放， 所以如果忘记了释放锁，一样会造成死锁。