java同步

synchronized 线程同步锁

测试代码：

package com.zhouxuyang.thread;

import org.junit.Test.None;

public class TestSynchronized {
    static String syn = "";

    public static void main(String[] args) {
        // 定义线程1
        Thread t1 = new Thread(new Runnable() {

            @Override
            public void run() {
                // TODO Auto-generated method stub
                synchronized (syn) {
                    try {
                        System.out.println(Thread.currentThread().getName() + "start ...");
                        Thread.sleep(1000);
                        System.out.println(Thread.currentThread().getName() + "end ...");
                    } catch (InterruptedException e) {
                        // TODO Auto-generated catch block
                        e.printStackTrace();
                    }
                }

            }
        }, "线程1");
        // 定义线程2
        Thread t2 = new Thread(new Runnable() {

            @Override
            public void run() {
                // TODO Auto-generated method stub
                synchronized (syn) {
                    try {
                        System.out.println(Thread.currentThread().getName() + "start ...");
                        Thread.sleep(1000);
                        System.out.println(Thread.currentThread().getName() + "end ...");
                    } catch (InterruptedException e) {
                        // TODO Auto-generated catch block
                        e.printStackTrace();
                    }
                }

            }
        }, "线程2");
        
        t1.start();
        t2.start();

    }
}

测试结果：

测试结果.png

说明：
在线程1和线程2中都有一个Thread.sleep(1000)，线程1和线程2同时开始，因为有：
synchronized (syn){
//代码块
}
所以两个线程开始后，因为线程1先执行synchronized（）{}，则等线程1执行完，线程2才能继续执行。

lock

四个获取锁方法
java.util.concurrent.locks
ock()方法是平常使用得最多的一个方法，就是用来获取锁。如果锁已被其他线程获取，则进行等待。
由于在前面讲到如果采用Lock，必须主动去释放锁，并且在发生异常时，不会自动释放锁。因此一般来说，使用Lock必须在try{}catch{}块中进行，并且将释放锁的操作放在finally块中进行，以保证锁一定被被释放，防止死锁的发生。

tryLock()方法是有返回值的，它表示用来尝试获取锁，如果获取成功，则返回true，如果获取失败（即锁已被其他线程获取），则返回false，也就说这个方法无论如何都会立即返回。在拿不到锁时不会一直在那等待。
tryLock(long time, TimeUnit unit)方法和tryLock()方法是类似的，只不过区别在于这个方法在拿不到锁时会等待一定的时间，在时间期限之内如果还拿不到锁，就返回false。如果如果一开始拿到锁或者在等待期间内拿到了锁，则返回true。
lockInterruptibly()方法比较特殊，当通过这个方法去获取锁时，如果线程正在等待获取锁，则这个线程能够响应中断，即中断线程的等待状态。也就使说，当两个线程同时通过lock.lockInterruptibly()想获取某个锁时，假若此时线程A获取到了锁，而线程B只有等待，那么对线程B调用threadB.interrupt()方法能够中断线程B的等待过程。
注意，当一个线程获取了锁之后，是不会被interrupt()方法中断的。因此当通过lockInterruptibly()方法获取某个锁时，如果不能获取到，只有进行等待的情况下，是可以响应中断的。

synchronized 和 Lock的区别

• Lock 不是 java 语言内置的，synchronized 是 java 语言的关键字，因此是内置特性。Lock是一个类，通过这个类可以实现同步访问。
• Lock和 synchronized 有一点非常大的不同， 采用synchronized不需要用户去手动释放锁，当synchronized方法或者synchronized代码块执行完之后，系统会自动让线程释放对锁的占用；而Lock则必须要用户去手动释放锁，如果没有主动释放锁，就有可能导致出现死锁现象。