（二）synchronized和重入锁

程序运行起来一定要保证线程安全，所以在多线程中一定要对临界区资源加锁，synchronized和重入锁都可以用来加锁。

synchronized

用法

对对象加锁，进入同步代码块时需要获得对象的锁。
对实例方法加锁，相当于对当前实例加锁，进入代码块要获得当前实例对象的锁
对静态方法加锁，相当于对当前类加锁，进入代码块要获得对象的锁

注意

锁要加在对象上

锁不能加在基本数据类型上，因为java的自动拆装箱，也不要在基本类型包装类加锁，如当我们需要计数时，可能会想到给一个Integer对象加锁，但是Integer对象每改变一次引用就换掉了。结果就是等待的线程永远都唤不醒。若我A中的唤醒的操作和改变值得操作换一下，还会报错java.lang.IllegalMonitorStateException，表示我没有这个对象的锁，因为对象已近变了

public class Test1 {
    public static void main(String[] args) {
        new T1ThreadB().start();
        new T1ThreadA().start();
    }
}
class T1ThreadA extends Thread{
    @Override
    public void run() {
        for(int i=0; i<10; i++) {
            synchronized (T1Data.count) {
                if(T1Data.count == 10) {
                    T1Data.count.notifyAll();
                }
                System.out.println("A加锁的对象" + T1Data.count.hashCode());
                T1Data.count = T1Data.count + 1;
            }
        }
    }
}
class T1ThreadB extends Thread{
    @Override
    public void run() {
        while(true) {
            synchronized (T1Data.count) {
                System.out.println("B加锁的对象" + T1Data.count.hashCode());
                if(T1Data.count == 10) {
                    break;
                }else {
                    try {
                        T1Data.count.wait();
                    } catch (InterruptedException e) {
                        // TODO Auto-generated catch block
                        e.printStackTrace();
                    }
                }
            }
        }
    }
}
class T1Data{
    public static Integer count = new Integer(0);
}

尽量缩小加锁的范围，提高效率

当一个类全是静态方法时，最好不要直接对静态方法加锁，因为这样是把锁加在了这个类上，实例方法也是一样，若传的的是一个对象，效率也会低。若是方法是对一个数据进行操作，最好直接加锁那个对象而不是方法。缩小加锁的范围。

public class Test2 {
    public static void main(String[] args) {
//      new T2ThreadA().start();
//      new T2ThreadB().start();
        new T2ThreadC().start();
        new T2ThreadD().start();
    }
}
class T2ThreadA extends Thread{
    @Override
    public void run() {
        T2Util.test1();
    }
}
class T2ThreadB extends Thread{
    @Override
    public void run() {
        T2Util.test2();
    }
}
class T2ThreadC extends Thread{
    @Override
    public void run() {
        T2Util.test3();
    }
}
class T2ThreadD extends Thread{
    @Override
    public void run() {
        T2Util.test4();
    }
}

class T2Util{
    public synchronized static void test1() {
        System.out.println(Thread.currentThread().getName() + "访问test1");
        try {
            Thread.currentThread().sleep(5000);
        } catch (InterruptedException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }
    }

    public synchronized static void test2() {
        System.out.println(Thread.currentThread().getName() + "访问test2");
        try {
            Thread.currentThread().sleep(5000);
        } catch (InterruptedException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }
    }

    public static LinkedList<String> list = new LinkedList<String>();

    public static void test3() {
        synchronized (T2Util.list) {
            list.add("aaa");
            System.out.println(Thread.currentThread().getName() + "访问test3");
        }
        try {
            Thread.currentThread().sleep(5000);
        } catch (InterruptedException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }
    }
    public static void test4() {
        synchronized (T2Util.list) {
            list.add("aaa");
            System.out.println(Thread.currentThread().getName() + "访问test4");
        }
        try {
            Thread.currentThread().sleep(5000);
        } catch (InterruptedException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }
    }
}

wait和notify的注意事项

很有可能有这样一种情景，两个线程同时操作一个集合，一个向其中添加数据，一个取数据，获取数据为null时就等待，添加的发现大小为1就唤醒。获取的线程拿着获取的数据继续操作。但是要注意一点，线程wait 后会释放获得的锁，这点sleep就不会释放。当被唤醒后首先去竞争锁，得到锁后从等待的后面开始执行，唤醒后那个取得的数据还是null，若后面的操作没有判断可能就会出错。在使用线程池的时候等待最好设置一个等待最长时间，因为有线程池时要注意自己的逻辑，可能有些线程就一直等下去了，这样程序就不能进行了。只有两个线程就不用。

public class Test3 {
    public static void main(String[] args) {
        new T3ThreadA().start();
        new T3ThreadB().start();
    }
}
class T3ThreadA extends Thread{
    @Override
    public void run() {
        try {
            Thread.currentThread().sleep(100);//为了让B有沉睡的可能
        } catch (InterruptedException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }
        for(int i=0; i<20; i++) {
            synchronized (T3Data.list) {
                String s = new String("呵呵" + i);
                T3Data.list.add(s);
                if(T3Data.list.size() == 1) {
                    T3Data.list.notifyAll();
                }
            }
        }
        T3Data.flag = false;
    }
}
class T3ThreadB extends Thread{
    @Override
    public void run() {
        boolean flag = true;
        while(flag) {
            String s = null;
            synchronized (T3Data.list) {
                System.out.println("B获得锁");
                try {
                    s = T3Data.list.getFirst();
                    T3Data.list.removeFirst();
                }catch (Exception e) {
                }
                if(s == null) {
                    if(T3Data.flag == false) {
                        flag = T3Data.flag;
                    }else {
                        try {
                            System.out.println("沉睡");
                            T3Data.list.wait(1000);//设置一个最长等待时间，有线程池时防止某个线程永远等下去，主要看自己的逻辑会不会出现这种情况。
                        } catch (InterruptedException e) {
                            // TODO Auto-generated catch block
                            e.printStackTrace();
                        }
                        System.out.println("被唤醒了");
                    }
                }
            }
            System.out.println("处理得到的数据" + s);
        }
    }
}
class T3Data{
    public static LinkedList<String> list = new LinkedList<String>();
    public static boolean flag = true;
}

重入锁

用法

重入锁和synchronized是差不多的，但是功能更强大，和synchronized相比，重入锁有显示的操作，必须手动加锁释放锁。对逻辑控制的灵活性好于synchronized。重入锁可以中断响应、限时等待。

ReentrantLock几个重要的方法

lock():获得锁，如果锁已被占用，则等待
lockInterruptibly():获得锁，优先响应中断
tryLock():尝试获得锁，成功返回true，不等待
tryLock(long time,TimeUnit unit):在给定的时间尝试获得锁
unlock():释放锁

Condition几个方法

synchronized有Object.wait()等方法，Condition的方法和那几个方法类似
await():线程等待，当中断时跳出等待
signal():唤醒一个等待的线程
signalAll():唤醒所有等待的线程
awaitUninterruptibly():等待，但不响应中断

要注意的和操作方法都和synchronized差不多，下面列出一个重入锁的基本使用

public class Test4 {
    public static void main(String[] args) {
        new T4ThreadA().start();
        new T4ThreadB().start();
    }
}

class T4ThreadA extends Thread{
    @Override
    public void run() {
        try {
            Thread.currentThread().sleep(100);//为了让B有沉睡的可能
        } catch (InterruptedException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }
        for(int i=0; i<20; i++) {
            try {
                T4Data.lock.lock();
                String s = new String("呵呵" + i);
                T4Data.list.add(s);
                if(T4Data.list.size() == 1) {
                    T4Data.condition.signalAll();
                }
            }catch (Exception e) {
                // TODO: handle exception
            }finally {
                T4Data.lock.unlock();
            }
        }
        System.out.println("A完成");
        T4Data.flag = false;
    }
}
class T4ThreadB extends Thread{
    @Override
    public void run() {
        boolean flag = true;
        while(flag) {
            String s = null;
            try{
                T4Data.lock.lock();
                System.out.println("B获得锁");
                try {
                    s = T4Data.list.getFirst();
                    T4Data.list.removeFirst();
                }catch (Exception e) {
                }
                if(s == null) {
                    if(T4Data.flag == false) {
                        flag = T4Data.flag;
                    }else {
                        System.out.println("沉睡");
                        T4Data.condition.await(10, TimeUnit.SECONDS);
                        System.out.println("被唤醒了");
                    }
                }
            }catch (Exception e) {
                // TODO: handle exception
            }finally {
                T4Data.lock.lock();
            }
            System.out.println("处理得到的数据" + s);
        }
    }
}

class T4Data{
    public static ReentrantLock lock = new ReentrantLock();
    public static Condition condition = lock.newCondition();
    public static LinkedList<String> list = new LinkedList<String>();
    public static boolean flag = true;
}