总结Lock和synchronized的区别

一、lock与sync的区别

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

二、例子使用

1、sync

package com.oyhp.lock;

import java.text.SimpleDateFormat;
import java.util.Date;

public class TestThreadSynchronized {
    public static String now(){
        return new SimpleDateFormat("HH:mm:ss").format(new Date());
    }
    
    public static void main(String[] args) {
        final Object someObject = new Object();
        Thread t1 = new Thread(){
            public void run(){
                try {
                    System.out.println(now() + " t1 线程已经运行");
                    System.out.println(now() + " " + this.getName() + 
                            " 试图占有对象: someObject");
                    synchronized (someObject) {
                        System.out.println(now() + " " + this.getName() + 
                                " 占有对象:someObject");
                        Thread.sleep(5000);
                        System.out.println(now() + " " + this.getName() +
                                " 释放对象:someObject");
                    }
                    System.out.println(now() + " t1线程结束");
                } catch (InterruptedException e) {
                    // TODO Auto-generated catch block
                    e.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 (someObject) {
                        System.out.println(now() + " " + this.getName() + 
                                " 占有对象:someObject");
                        Thread.sleep(5000);
                        System.out.println(now() + " " + this.getName() +
                                " 释放对象:someObject");
                        System.out.println(now() + " t2线程结束");
                    }
                } catch (InterruptedException e) {
                    // TODO Auto-generated catch block
                    e.printStackTrace();
                }
            }
        };
        t2.setName("t2");
        t2.start();
    }
}

2、lock

package com.oyhp.lock;

import java.text.SimpleDateFormat;
import java.util.Date;
import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;

public class TestThreadLock {
    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);
    }
    
    public static void main(String[] args) {
        Lock lock = new ReentrantLock();
        
        Thread t1 = new Thread(){
            @Override
            public void run() {
                // TODO Auto-generated method stub
                try {
                    log("线程启动");
                    log("试图占有对象:lock");
                    lock.lock();
                    log("占有对象:lock");
                    log("进行5秒的业务操作");
                    Thread.sleep(5000);
                } catch (InterruptedException e) {
                    // TODO Auto-generated catch block
                    e.printStackTrace();
                }finally{
                    log("释放对象:lock");
                    lock.unlock();
                }
                log("线程结束");
            }
        };
        t1.setName("t1");
        t1.start();
        
        try {
            Thread.sleep(2000);
        } catch (InterruptedException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }
        Thread t2 = new Thread(){
            @Override
            public void run() {
                // TODO Auto-generated method stub
                try {
                    log("线程启动");
                    log("试图占有对象:lock");
                    lock.lock();
                    log("占有对象:lock");
                    log("进行5秒的业务操作");
                    Thread.sleep(5000);
                } catch (InterruptedException e) {
                    // TODO Auto-generated catch block
                    e.printStackTrace();
                }finally{
                    log("释放对象:lock");
                    lock.unlock();
                }
                log("线程结束");
            }
        };
        t2.setName("t2");
        t2.start();
    }
}

3、trylock

package com.oyhp.lock;

import java.text.SimpleDateFormat;
import java.util.Date;
import java.util.concurrent.TimeUnit;
import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;

public class TestTryLock {
    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);
    }
    
    public static void main(String[] args) {
        Lock lock = new ReentrantLock();
        Thread t1 = new Thread(){
            @Override
            public void run() {
                // TODO Auto-generated method stub
                boolean locked = false;
                try {
                    log("线程启动");
                    log("试图占有对象:lock");
                    
                    locked = lock.tryLock(1,TimeUnit.SECONDS);
                    
                    if(locked){
                        log("占有对象:lock");
                        log("进行5秒的业务操作");
                        Thread.sleep(5000);
                    }else{
                        log("经过1秒的努力，还没有占有对象，放弃占有");
                    }
                } catch (InterruptedException e) {
                    // TODO Auto-generated catch block
                    e.printStackTrace();
                }finally{
                    if(locked){
                        log("释放对象:lock");
                        lock.unlock();
                    }
                }
                log("线程结束");
            }
        };
        t1.setName("t1");
        t1.start();
        
        try {
            Thread.sleep(2000);
        } catch (InterruptedException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }
        
        Thread t2 = new Thread(){
            @Override
            public void run() {
                // TODO Auto-generated method stub
                boolean locked = false;
                try {
                    log("线程启动");
                    log("试图占有对象:lock");
                    
                    locked = lock.tryLock(1,TimeUnit.SECONDS);
                    
                    if(locked){
                        log("占有对象:lock");
                        log("进行5秒的业务操作");
                        Thread.sleep(5000);
                    }else{
                        log("经过1秒的努力，还没有占有对象，放弃占有");
                    }
                } catch (InterruptedException e) {
                    // TODO Auto-generated catch block
                    e.printStackTrace();
                }finally{
                    if(locked){
                        log("释放对象:lock");
                        lock.unlock();
                    }
                }
                log("线程结束");
            }
        };
        t2.setName("t2");
        t2.start();
    }
}
4、线程交互

package com.oyhp.lock;

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 TestThread {
    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);
    }
    
    public static void main(String[] args) {
        Lock lock = new ReentrantLock();
        Condition condition = lock.newCondition();
        
        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) {
                    e.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 block
            e1.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) {
                    e.printStackTrace();
                } finally {
                    log("释放对象：lock");
                    lock.unlock();
                }
                log("线程结束");
            }
        };
        t2.setName("t2");
        t2.start();
    }
}