lock（锁）

lock
lock于synchronized相比更有优势，或者是说有不同的地方。
lock于synchronized的区别？
synchronized一个线程获取锁别的线程都在等待，synchronized当前的方法或者代码块


会自动释放锁，然后让别的线程去获取。synchronized代码块抛出异常也会自动释放锁
lock就是一个线程获取锁，别的线程会尝试获取锁，如果获取多的话也没关系，也不会等


待，做别的事情，其次lock需要手动释放锁。lock抛出异常不会自动释放锁，也要手动释


放锁，lock手动释放锁需要写在finnlly里面。
源码：
lock是一个接口。有lock方法。有lockInterruptibly方法，还有trylock，还有


unlock.
ReentrantLock是对lock的实现。Lock就是一把锁。或取一个对象的锁。lock.lock();
如下：第二个线程锁不会获取。只会输出1  11  2 ，不会输出22。
package test08;
import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;
public class Test {
            public static void main(String[] args) {
               //lock
              final Lock lock = new ReentrantLock();
                    new Thread(){
                          public void run(){
                                System.out.println(1);
                               lock.lock();
                                System.out.println(11);
            }
         }.start();
                    new Thread(){
                      public void run(){
                           System.out.println(2);
                           lock.lock();
                          System.out.println(22);
    }
     }.start();
}
}
要想输出需要自动释放锁。在输出11或者输出22的那try  一下，写finally，在finally


里手动释放锁。
package test08;
import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;
public class Test {
             public static void main(String[] args) {
              //lock
            final Lock lock = new ReentrantLock();
               new Thread(){
                      public void run(){
                         System.out.println(1);
                         lock.lock();
               try {
                      System.out.println(11);
             } finally{
                  lock.unlock();
                 System.out.println(111);
        }
      }
    }.start();
              new Thread(){
                     public void run(){
                         System.out.println(2);
                        lock.lock();
                       System.out.println(22);
           }
         }.start();
}
}
LOCK
第一个线程开始获取锁，就会输出我以获取锁，睡眠3秒释放锁，第二个线程无法获取锁，


就会输出没有获取锁。
package test08;
import java.util.concurrent.TimeUnit;
import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;
public class Test {
    public static void main(String[] args) {
    final Lock lock = new ReentrantLock();
        new Thread(){
             public void run(){
                System.out.println("开始。。。");
             if(lock.tryLock()){
           try{
                 System.out.println("我以获取到锁");
             }finally{
            try {
              Thread.sleep(3000);
              } catch (InterruptedException e) {
           // TODO Auto-generated catch block
         e.printStackTrace();
  }
           lock.unlock();
  }
           }else{
         System.out.println("我没有获取到锁");
  }
 }
}.start();
       new Thread(){
         public void run(){
            System.out.println("开始。。。");
           if(lock.tryLock()){
          try{
            System.out.println("我以获取到锁");
        }finally{
            lock.unlock();
}
             }else{
               System.out.println("我没有获取到锁");
 }
 }
 }.start();
}
}
第一个线程开始获取锁，就会输出我以获取锁，睡眠3秒释放锁，第二个线程5秒后获取锁


，就会输出我以获取锁
package test08;
import java.util.concurrent.TimeUnit;
import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;
public class Test {
public static void main(String[] args) {
     final Lock lock = new ReentrantLock();
      new Thread(){
         public void run(){
                 System.out.println("开始。。。");
         if(lock.tryLock()){
          try{
                System.out.println("我以获取到锁");
         }finally{
         try {
               Thread.sleep(3000);
            } catch (InterruptedException e) {
          // TODO Auto-generated catch block
           e.printStackTrace();
   }
         lock.unlock();
 }
   }else{
      System.out.println("我没有获取到锁");
 }
 }
}.start();
      new Thread(){
         public void run(){
              System.out.println("开始。。。");
        try {
             if(lock.tryLock(5000L, TimeUnit.MILLISECONDS)){
              try{
           System.out.println("我以获取到锁");
            }finally{
                lock.unlock();
    }
    }else{
             System.out.println("我没有获取到锁");
    }
    } catch (InterruptedException e) {
             // TODO Auto-generated catch block
                  e.printStackTrace();
   }
    }
  }.start();
}
}