Java并发编程从入门到精通

Java内存模型与多线程：

线程不安全与线程安全：
 线程安全问题阐述：
  多条语句操作多个线程共享的资源时，一个线程只执行了部分语句，还没执行完，另一个线程又进来操作共享数据（执行语句），导致共享数据最终结果出现误差；所以就是看一个线程能否每次在没有其他线程进入的情况下操作完包含共享资源的语句块，如果能就没有安全问题，不能就有安全问题；
 如何模拟多线程的安全问题：
  用Thread.sleep()方法模拟； 放在哪：放在多线程操作共享数据的语句块之间（使正在运行的线程休息一会，让其他线程执行，就会出现共享数据错误的问题）；
 如何解决线程安全问题：
  解决思想：
   只有当一个线程执行完所有语句之后，才能让另外一个线程进来再进行操作；
  具体操作：
   加锁，对操作共享数据的代码块加锁，实现在一个线程操作共享数据时，其它线程不能再进来操作，直到本线程执行完之后其它线程才能进来执行；
  哪些代码块需要加锁（同步）：
   明确每个线程都会操作的代码块；
   明确共享资源；
   明确代码块中操作共享资源语句块，这些语句块就是需要加锁的代码块；
  具体解决方式：（以synchronized为例）
   同步代码块：
    synchronized(对象)
    {
     需要被同步的代码块;
    }
   同步方法：
    就是把需要同步的代码块放到一个函数里面，代码块原来所在的函数里面可能还有其他不需要同步的代码块（所以不能每次直接同步原来所在的方法），需要仔细分析；
 确保没有线程安全问题的两个前提：
  至少有两个及两个以上的线程操作共享资源；
  所有线程使用的锁是同一个锁；
  注意：加了锁之后还出现线程安全问题的话，说明上面两个前提肯定没有全部满足；
 想实现线程安全大致有三种方法：
  多实例，也就是不使用单例模式了（单例模式在多线程下是不安全的）；
  使用java.util.concurrent下面的类库；
  使用锁机制synchronized、lock方式；

/**
 * 线程安全实例：（加锁的情况下）假设5个用户，都来给一个数字加1的工作，那么最后应该是得到加5的结果
 */
package thread02;

public class ThreadSafeTest01
{
    public static void main(String[] args)
    {
        Count2 count = new Count2();
        
        for(int i=0;i<5;i++)
        {
            Person2 person = new Person2(count);
            Thread thread = new Thread(person);
            thread.start();
        }
        
        try
        {
            Thread.sleep(1000);
        } 
        catch (InterruptedException e)
        {
            e.printStackTrace();
        }
        
        System.out.println("程序结束，num最后的值：" + count.getNum());
    }
}

class Count2
{
    private int num = 0;
    
    // synchronized必须放在返回值类型前面
    public synchronized void add()
    {
        try
        {
            Thread.sleep(50);
        } 
        catch (InterruptedException e)
        {
            e.printStackTrace();
        }
        
        num += 1;
        
        System.out.println(Thread.currentThread().getName() + ":" + num);
    }
    
    public int getNum()
    {
        return num;
    }
}

class Person2 implements Runnable
{
    private Count2 count;
    
    public Person2(Count2 count)
    {
        this.count = count;
    }
    
    @Override
    public void run()
    {
        count.add();
    }
}

/*
最终结果：
Thread-0:1
Thread-4:2
Thread-3:3
Thread-2:4
Thread-1:5
程序结束，num最后的值：5

根据结果可以看出：线程安全；线程按进入顺序主次将num值加1，最后结果始终为5；

*/

/**
 * 线程不安全实例：（不加锁的情况下）假设5个用户，都来给一个数字加1的工作，那么最后应该是得到加5的结果
 */
package thread02;

public class ThreadUnSafeTest01
{
    public static void main(String[] args)
    {
        Count count = new Count();
        
        for(int i=0;i<5;i++)
        {
            Person person = new Person(count);
            Thread thread = new Thread(person);
            thread.start();
        }
        
        try
        {
            Thread.sleep(1000);
        } 
        catch (InterruptedException e)
        {
            e.printStackTrace();
        }
        
        System.out.println("程序执行结束，num最后结果：" + count.getNum());
    }
}

class Count
{
    private int num = 0;
    
    public void add()
    {
        try
        {
            // 模拟做事
            Thread.sleep(50);
        } 
        catch (InterruptedException e)
        {
            e.printStackTrace();
        }
        
        num += 1;
        
        System.out.println(Thread.currentThread().getName() + ":" + num);
    }

    public int getNum()
    {
        return num;
    }
    public void setNum(int num)
    {
        this.num = num;
    }
}

class Person implements Runnable
{
    private Count count;
    
    public Person(Count count)
    {
        this.count = count;
    }
    
    @Override
    public void run()
    {
        count.add();
    }
}

/*
最后结果：
Thread-1:2
Thread-4:4
Thread-3:4
Thread-2:2
Thread-0:2
程序执行结束，num最后结果：4

根据结果可以看出：线程不安全，并不是每个线程按顺序将num按序加1；

*/

为什么单例在多线程下是不安全的：
 因为在多线程下可能会创建多个实例，不能保证原子性，违背设计单例模式的初衷；

synchronized：
 详解：
  隐式锁，同步锁，内置锁，监视器锁，可重入锁；
  为了解决线程同步问题而生；
  当用它来修饰一个代码块或一个方法时，能够保证在同一时刻最多只有一个线程执行该段代码（或方法）；
  采用synchronized修饰符实现的同步机制叫做互斥锁机制，它所获得的锁（对象，锁必须是对象，就是引用类型，不能是基本数据类型）叫做互斥锁；每个对象都有一个monitor（锁标记），当线程拥有这个锁标记时才能访问这个资源，没有锁标记便进入锁池（谁进入锁池）；对于任何一个对象，系统都会为其创建一个互斥锁，这个锁是为了分配给线程的，防止打断原子操作；每个对象的锁只能分配给一个线程，因此叫做互斥锁；
  是可重入锁：一个线程可以多次获得同一个对象的互斥锁；
 使用同步机制获取互斥锁的规则说明：
  如果同一个方法内同时有两个或更多线程，则每个线程有自己的局部变量拷贝；（不解）
  类的每个实例都有自己的对象级别锁（一个实例对象就是一个互斥锁，同一个类的两个实例对象对应的互斥锁是不一样的）；当一个线程访问实例对象中的synchronized同步代码块或同步方法时，该线程便获取了该实例的对象级别锁（就是当前对象的意思）；
  持有一个对象级别锁不会阻止该线程被交换出来（不解），也不会阻塞其他线程访问同一实例对象中的非synchronized代码；
  持有对象级别锁的线程会让其他线程阻塞在所有的synchronized代码外；
  使用synchronized（obj）同步语句块，可以获取指定对象上的对象级别锁；
  类级别锁被特定类的所有实例共享，它用于控制对static成员变量以及static方法的并发访问；具体用法与对象级别锁相似；
 synchronized的不同写法对于性能和执行效率的优劣程度排序：
  同步方法体 < 同步方法块（锁不是最小的锁） < 同步方法块（锁是最小的锁）；

/**
 * 一个正确的例子：虽然synchronized的写法不一样，但下面的这两个方法对于多线程来说是线程安全的；
 * 因为满足两个前提：多个线程（至少两个）线程操作同一个共享资源；多个线程使用的锁是同一个锁（本例中是当前对象）；
 */
package thread02;

public class SynchronizedTest01
{
    public static void main(String[] args)
    {
        Count1 count = new Count1();
        
        for(int i=1;i<=6;i++)
        {
            Person1 person = new Person1(count);
            Thread thread = new Thread(person);
            
            if(i%2 == 0)
                person.setFlag(false);
            else
                person.setFlag(true);
            
            thread.start();
        }
    }
}

class Count1
{
    private int sum = 0;
    
    // 使用的锁是当前对象
    public synchronized void add()
    {
        try
        {
            Thread.sleep(50);
        } 
        catch (InterruptedException e)
        {
            e.printStackTrace();
        }
        
        sum += 1;
        System.out.println(Thread.currentThread().getName() + " -> add() -> " + sum);
    }
    
    public void add2()
    {
        // 使用的锁是当前对象
        synchronized (this)
        {
            try
            {
                Thread.sleep(50);
            } 
            catch (InterruptedException e)
            {
                e.printStackTrace();
            }
            
            sum += 1;
            System.out.println(Thread.currentThread().getName() + " -> add2() -> " + sum);
        }
    }
}

class Person1 implements Runnable
{
    private Count1 count;
    boolean flag = false;
    
    public Person1(Count1 count)
    {
        this.count = count;
    }

    @Override
    public void run()
    {
        if(flag)
            count.add();
        else
            count.add2();
    }

    public boolean isFlag()
    {
        return flag;
    }
    public void setFlag(boolean flag)
    {
        this.flag = flag;
    }
    
}

/*
最终结果：
Thread-0 -> add() -> 1
Thread-5 -> add2() -> 2
Thread-4 -> add() -> 3
Thread-3 -> add2() -> 4
Thread-2 -> add() -> 5
Thread-1 -> add2() -> 6

根据结果：程序是线程安全的，因为满足线程安全的两个前提
*/

/**
 * 一个正确的例子：下面的这两个方法对于多线程来说是线程不安全的；
 * 因为违背了线程安全的两个前提中的一个：多个线程使用同一个锁；及本例两个方法使用的锁是不一样的
 */
package thread02;

public class SynchronizedTest02
{
    public static void main(String[] args)
    {
        Count3 count = new Count3();
        
        for(int i=1;i<=6;i++)
        {
            Person3 person = new Person3(count);
            Thread thread = new Thread(person);
            
            if(i%2 ==0)
                person.setFlag(false);
            else
                person.setFlag(true);
            
            thread.start();
        }
    }
}

class Count3
{
    private int sum = 0;
    private byte[] bt = new byte[1];
    
    // 使用的锁是当前对象this
    public synchronized void add()
    {
        try
        {
            Thread.sleep(50);
        } 
        catch (InterruptedException e)
        {
            e.printStackTrace();
        }
        
        sum += 1;
        System.out.println(Thread.currentThread().getName() + " -> add() -> " + sum);
    }
    
    public void add2()
    {
        // 使用的锁不是当前对象this，而是自定义的对象bt
        synchronized (bt)
        {
            try
            {
                Thread.sleep(50);
            } 
            catch (InterruptedException e)
            {
                e.printStackTrace();
            }
            
            sum += 1;
            System.out.println(Thread.currentThread().getName() + " -> add() -> " + sum);
        }
    }
}

class Person3 implements Runnable
{
    private Count3 count;
    private boolean flag = false;
    
    public Person3(Count3 count)
    {
        this.count = count;
    }

    @Override
    public void run()
    {
        if(flag)
            count.add();
        else
            count.add2();
    }
    
    public void setFlag(boolean flag)
    {
        this.flag = flag;
    }
}

/*
最终结果：
Thread-1 -> add() -> 2
Thread-0 -> add() -> 2
Thread-5 -> add() -> 3
Thread-4 -> add() -> 4
Thread-3 -> add() -> 5
Thread-2 -> add() -> 6

根据结果：程序是线程不安全的，因为多个线程没有使用同一个锁
*/

/**
 * 实例证明synchronized的不同写法对于性能和执行效率的优劣程度排序：
 *   同步方法体 < 同步方法块（锁不是最小的锁） < 同步方法块（锁是最小的锁）；
 */
package thread02;

public class SynchronizedTest03
{
    public static void main(String[] args)
    {
        Count4 count = new Count4();
        Thread thread = new Thread(count);
        thread.start();
    }
}

class Count4 implements Runnable
{
    private int sum = 0;
    private byte[] bt = new byte[1];
    
    public synchronized void add()
    {
        try
        {
            Thread.sleep(1000);
        } 
        catch (InterruptedException e)
        {
            e.printStackTrace();
        }
        
        sum += 1;
        System.out.println("sum：" + sum);
    }
    
    public void add2()
    {
        long beginTime = System.currentTimeMillis();
        
        synchronized (this)
        {
            try
            {
                Thread.sleep(1000);
            } 
            catch (InterruptedException e)
            {
                e.printStackTrace();
            }
            
            sum += 1;
            System.out.println("sum：" + sum);
        }
        
        long endTime = System.currentTimeMillis();
        long result = endTime - beginTime;
        System.out.println("使用同步方法块（锁不是最小的锁）耗时：" + result);
    }
    
    public void add3()
    {
        long beginTime = System.currentTimeMillis();
        
        synchronized (bt)
        {
            try
            {
                Thread.sleep(1000);
            } 
            catch (InterruptedException e)
            {
                e.printStackTrace();
            }
            
            sum += 1;
            System.out.println("sum：" + sum);
        }
        
        long endTime = System.currentTimeMillis();
        long result = endTime - beginTime;
        System.out.println("使用同步方法块（锁是最小的锁）耗时：" + result);
    }
    
    @Override
    public void run()
    {
        long beginTime1 = System.currentTimeMillis();
        add();
        long endTime1 = System.currentTimeMillis();
        long result1 = endTime1 - beginTime1;
        System.out.println("使用同步方法体耗时：" + result1);
        
        long beginTime2 = System.currentTimeMillis();
        add2();
        long endTime2 = System.currentTimeMillis();
        long result2 = endTime2 - beginTime2;
        System.out.println("使用同步方法块（锁不是最小的锁）耗时：" + result2);
        
        long beginTime3 = System.currentTimeMillis();
        add3();
        long endTime3 = System.currentTimeMillis();
        long result3 = endTime3 - beginTime3;
        System.out.println("使用同步方法块（锁是最小的锁）耗时：" + result3);
    }
}

/*
最终结果：
sum：1
使用同步方法体耗时：1011
sum：2
使用同步方法块（锁不是最小的锁）耗时：1007
使用同步方法块（锁不是最小的锁）耗时：1007
sum：3
使用同步方法块（锁是最小的锁）耗时：1001
使用同步方法块（锁是最小的锁）耗时：1001

根据结果：同步方法体 < 同步方法块（锁不是最小的锁） < 同步方法块（锁是最小的锁）；
*/

显式锁：
 详解：
  为什么叫显式锁，因为所有加锁和解锁的方法都是显示的，即必须手动加锁和释放锁；
  为了保证锁最终一定会被释放（可能会有异常发生），要把互斥区放在try语句块内，并在finally语句块中释放锁；尤其当有return语句时，return语句必须放在try字句中，以确保unlock（）不会过早发生，从而将数据暴露给第二个任务；
  采用lock加锁和释放锁的一般形式如下：

 接口：Lock ReadWriteLock
 实现类：ReentrantLock ReentrantReadWriteLock
  ReentrantLock是Lock接口的实现类， ReentrantReadWriteLock是ReadWriteLock接口的实现类；
  ReadWriteLock并不是Lock的子接口，只是ReadWriteLock借助Lock来实现读写两个锁的并存、互斥的机制；

Lock：是一个接口，提供了无条件的、可轮询的、定时的、可中断的锁获取操作，所有加锁和解锁的方法都是显示的；
ReentrantLock：在竞争条件下，ReentrantLock的实现要比现在的synchronized实现更具有可伸缩性；（有可能在JVM的将来版本中改进synchronized的竞争性能）这意味着当许多线程都竞争相同锁定时，使用ReentrantLock的吞吐量通常要比synchronized好；换句话说，当许多线程试图访问ReentrantLock保护的共享资源时，JVM将花费较少的时间来调度线程，而用更多时间执行线程；ReentrantLock是在工作中对方法块加锁使用频率最高的；但ReentrantLock也有一个主要缺点：它可能忘记释放锁定；

/**
 * ReentrantLock的使用规范
 */
package thread02;

import java.util.concurrent.locks.ReentrantLock;

public class ReentrantLockTest01
{
    public static void main(String[] args)
    {
        Count5 count = new Count5();
        
        new Thread()
        {
            public void run() 
            {
                count.get();
            };
        }.start();
    }
}

class Count5
{
    // ReentrantLock的使用规范：在try..catch..外先加锁；在try..catch..中执行业务逻辑；在finally中释放锁；
    // 只是建议，具体情况具体分析
    
    final ReentrantLock lock = new ReentrantLock();
    
    public void get()
    {
        // ReentrantLock只适用于方法块，不适用于方法；即只能在方法块上加锁，不能在方法上加锁
        lock.lock();  // 1.加锁
        try
        {
            // 2.执行相关的业务逻辑
            System.out.println(Thread.currentThread().getName() + " get begin...");
            Thread.sleep(1000L);
            System.out.println(Thread.currentThread().getName() + " get end...");
        } 
        catch (InterruptedException e)
        {
            e.printStackTrace();
        }
        finally
        {
            // 3.解锁
            lock.unlock();
        }
    }
}

/**
 * 实例比较证明：因为ReentrantLock只适用于方法块，所以每个线程在方法块中新定义ReentrantLock锁时，这些锁都是相互独立的，不是互斥的，
 * 在这种情况下是线程不安全的；而synchronized对象之间是互斥关系，只要使用synchronized锁住方法块，那么每个线程必须按顺序进入方法块
 * 执行任务，且每次只能有一个线程进入方法块执行任务，这种情况下是线程安全的；
 * 得出一个结论：要想线程安全，ReentrantLock锁的定义要放到方法的外面，在方法内进行加锁解锁操作；这样多线程访问方法中的方法块时，使用的
 * 锁就是同一个锁，这样就能实现线程安全；
 */
package thread02;

import java.util.concurrent.locks.ReentrantLock;

public class ReentrantLockTest02
{
    public static void main(String[] args)
    {
        Count6 count = new Count6();
        
        // 以下四个线程使用的是同一个共享资源：count
        for(int i=0;i<2;i++)
        {
            new Thread()
            {
                public void run() 
                {
                    count.get();
                };
            }.start();
        }
        
        for(int i=0;i<2;i++)
        {
            new Thread()
            {
                public void run() 
                {
                    count.put();
                };
            }.start();
        }
    }
}

class Count6
{
    // ReentrantLock锁在方法外定义，在多线程情况下，是安全的
    // final ReentrantLock lock = new ReentrantLock();
    
    public void get()
    {
        // 方法里面的变量只能加final或不加任何限制符；因为在方法中，是局部变量，只能在方法中使用，作用域已经限定死了，不需要再加访问限定符；
        // ReentrantLock锁在方法内定义，在多线程情况下，是不安全的
        final ReentrantLock lock = new ReentrantLock();
        
        lock.lock();
        try
        {
            System.out.println(Thread.currentThread().getName() + " get begin...");
            Thread.sleep(1000L);
            System.out.println(Thread.currentThread().getName() + " get end...");
        } 
        catch (InterruptedException e)
        {
            e.printStackTrace();
        }
        finally
        {
            lock.unlock();
        }
    }
    
    public void put()
    {
        synchronized (this)
        {
            try
            {
                System.out.println(Thread.currentThread().getName() + " put begin...");
                Thread.sleep(1000L);
                System.out.println(Thread.currentThread().getName() + " put end...");
            } 
            catch (InterruptedException e)
            {
                e.printStackTrace();
            }
        }
    }
}

/*
最终结果：每次可能不一样
Thread-1 get begin...
Thread-0 get begin...
Thread-2 put begin...
Thread-1 get end...
Thread-2 put end...
Thread-3 put begin...
Thread-0 get end...
Thread-3 put end...

结果证明：ReentrantLock锁在方法内定义，在多线程情况下，是不安全的；synchronized (this)是安全的
*/

/**
 * 实例证明：以下两个方法之间的锁是独立的；多线程场景下是不安全的
 */
package thread02;

import java.util.concurrent.locks.ReentrantLock;

public class ReentrantLockTest03
{
    public static void main(String[] args)
    {
        Count7 count = new Count7();
        
        for(int i=0;i<2;i++)
        {
            new Thread()
            {
                public void run() 
                {
                    count.get();
                };
            }.start();
        }
        
        for(int i=0;i<2;i++)
        {
            new Thread()
            {
                public void run() 
                {
                    count.put();
                };
            }.start();
        }
    }
}

class Count7
{
    public void get()
    {
        // ReentrantLock锁定义在方法内，每次一个线程访问这个方法都要新建一个锁，而这些新建的锁都是相互独立了，不是互斥的，互不影响
        final ReentrantLock lock = new ReentrantLock();
        lock.lock();
        try
        {
            System.out.println(Thread.currentThread().getName() + " get begin...");
            Thread.sleep(1000L);
            System.out.println(Thread.currentThread().getName() + " get end...");
        } 
        catch (InterruptedException e)
        {
            e.printStackTrace();
        }
        finally
        {
            lock.unlock();
        }
    }
    
    public void put()
    {
        final ReentrantLock lock = new ReentrantLock();
        lock.lock();
        try
        {
            System.out.println(Thread.currentThread().getName() + " put begin...");
            Thread.sleep(1000L);
            System.out.println(Thread.currentThread().getName() + " put end...");
        } 
        catch (InterruptedException e)
        {
            e.printStackTrace();
        }
        finally
        {
            lock.unlock();
        }
    }
}

/*
最终结果：
Thread-0 get begin...
Thread-2 put begin...
Thread-1 get begin...
Thread-3 put begin...
Thread-1 get end...
Thread-3 put end...
Thread-0 get end...
Thread-2 put end...

结果证明：这样写法是线程不安全的
*/

/**
 * 实例证明：以下两个方法之间的锁是互斥的；多线程场景下是安全的
 */
package thread02;

import java.util.concurrent.locks.ReentrantLock;

public class ReentrantLockTest04
{
    public static void main(String[] args)
    {
        Count8 count = new Count8();
        
        for(int i=0;i<2;i++)
        {
            new Thread()
            {
                public void run() 
                {
                    count.get();
                };
            }.start();
        }
        
        for(int i=0;i<2;i++)
        {
            new Thread()
            {
                public void run() 
                {
                    count.put();
                };
            }.start();
        }
    }
}

class Count8
{
    // ReentrantLock锁定义在方法之外，所有方法都使用这个锁，所以是线程安全的
    private ReentrantLock lock = new ReentrantLock();
    
    public void get()
    {
        lock.lock();
        try
        {
            System.out.println(Thread.currentThread().getName() + " get begin...");
            Thread.sleep(1000L);
            System.out.println(Thread.currentThread().getName() + " get end...");
        } 
        catch (InterruptedException e)
        {
            e.printStackTrace();
        }
        finally
        {
            lock.unlock();
        }
    }
    
    public void put()
    {
        lock.lock();
        try
        {
            System.out.println(Thread.currentThread().getName() + " put begin...");
            Thread.sleep(1000L);
            System.out.println(Thread.currentThread().getName() + " put end...");
        } 
        catch (InterruptedException e)
        {
            e.printStackTrace();
        }
        finally
        {
            lock.unlock();
        }
    }
}

/*
最终结果：
Thread-0 get begin...
Thread-0 get end...
Thread-1 get begin...
Thread-1 get end...
Thread-3 put begin...
Thread-3 put end...
Thread-2 put begin...
Thread-2 put end...

结果证明：这样写是线程安全的
*/

Lock和synchronized的比较：
 Lock使用起来比较灵活，但是必须有释放锁的动作配合；
 Lock必须手动释放和开启锁，而synchronized不需要手动释放和开启锁；
 Lock只适用于代码块锁，而synchronized对象之间是互斥关系；

ReadWriteLock接口：
 提供了readLock和writeLock两种锁的操作机制；
 一个资源能够被多个读线程访问，或者被一个写线程访问，但是不能同时存在读写线程；也就是说读写锁适用的场合是一个共享资源被大量读取操作，而只有少量的写操作；
 在ReadWriteLock中，每次读取共享数据就需要读取锁，当需要修改共享数据时就需要写入锁；看起来好像是两个锁，其实不是；
 ReentrantReadWriteLock类：
 ReadWriteLock接口唯一的实现类；
 主要应用场景是：当有很多线程都从某个数据结构读取数据，而很少有线程对其进行修改时，在这种情况下，允许读取器线程共享访问是合适的，写入器线程依然必须是互斥访问的；
 主要特性：
  公平性：
  重入性：
  锁降级：
  锁升级：
  锁获取中断：
  条件变量：
  重入数：
 以上概括起来就是读写锁的机制：读-读不互斥、读-写互斥、写-写互斥；

/**
 * 读写锁 ReentrantReadWriteLock 使用规范；
 * 只是建议，具体情况具体分析
 */
package thread02;

import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantReadWriteLock;

public class ReentrantReadWriteLockTest01
{
    public static void main(String[] args)
    {
        Count9 count = new Count9();
        
        for(int i=0;i<2;i++)
        {
            new Thread()
            {
                public void run() 
                {
                    count.get();
                };
            }.start();
        }
        
        for(int i=0;i<2;i++)
        {
            new Thread()
            {
                public void run() 
                {
                    count.put();
                };
            }.start();
        }
    }
}

class Count9
{
    // 1.创建一个 ReentrantReadWriteLock 对象
    private ReentrantReadWriteLock rwl = new ReentrantReadWriteLock();
    // 2.得到一个可被多个读操作共用的读锁（会排斥所有写操作）
    private Lock readLock = rwl.readLock();
    // 3.得到一个写锁（会排斥所有其它读操作和写操作）
    private Lock writeLock = rwl.writeLock();
    
    public void get()
    {
        // 4.在try..catch..外，实现业务逻辑前，加（读写）锁
        readLock.lock();
        try
        {
            // 5.在try..catch..中实现具体的业务逻辑
            System.out.println(Thread.currentThread().getName() + " read begin...");
            Thread.sleep(1000L);
            System.out.println(Thread.currentThread().getName() + " read end...");
        } 
        catch (InterruptedException e)
        {
            e.printStackTrace();
        }
        finally
        {
            // 6.在finally中释放锁
            readLock.unlock();
        }
    }
    
    public void put()
    {
        writeLock.lock();
        try
        {
            System.out.println(Thread.currentThread().getName() + " write begin...");
            Thread.sleep(1000L);
            System.out.println(Thread.currentThread().getName() + " write end...");
        } 
        catch (InterruptedException e)
        {
            e.printStackTrace();
        }
        finally
        {
            writeLock.unlock();
        }
    }
}

/*
最终结果：
Thread-0 read begin...
Thread-1 read begin...
Thread-0 read end...
Thread-1 read end...
Thread-2 write begin...
Thread-2 write end...
Thread-3 write begin...
Thread-3 write end...

根据结果：读-读不互斥、写-写互斥
*/

/**
 * 实例：ReadLock（读锁）和 WriteLock（写锁）单独使用的场景
 */
package thread02;

import java.util.concurrent.locks.ReentrantReadWriteLock;

public class ReentrantReadWriteLockTest02
{
    public static void main(String[] args)
    {
        // 注意final的效果，可加可不加
        final Count10 count = new Count10();
        
        for(int i=0;i<2;i++)
        {
            new Thread()
            {
                public void run() 
                {
                    count.get();
                };
            }.start();
        }
        
        for(int i=0;i<2;i++)
        {
            new Thread()
            {
                public void run() 
                {
                    count.put();
                };
            }.start();
        }
    }
}

class Count10
{
    // 注意final的效果，可加可不加
    private final ReentrantReadWriteLock rwl = new ReentrantReadWriteLock();
    
    public void get()
    {
        // 上读锁，其它线程只能读不能写，具有高并发性
        rwl.readLock().lock();
        try
        {
            System.out.println(Thread.currentThread().getName() + " read begin...");
            Thread.sleep(1000L);  // 模拟干活
            System.out.println(Thread.currentThread().getName() + " read end...");
        } 
        catch (InterruptedException e)
        {
            e.printStackTrace();
        }
        finally
        {
            // 释放毒素哦，最好放在finally中
            rwl.readLock().unlock();
        }
    }
    
    public void put()
    {
        // 上写锁，具有阻塞性
        rwl.writeLock().lock();
        try
        {
            System.out.println(Thread.currentThread().getName() + " write begin...");
            Thread.sleep(1000L);  // 模拟干活
            System.out.println(Thread.currentThread().getName() + " write end...");
        } 
        catch (InterruptedException e)
        {
            e.printStackTrace();
        }
        finally
        {
            // 释放写锁，最好放在finally中
            rwl.writeLock().unlock();
        }
    }
}

/**
 * 实例：ReadLock（读锁）和 WriteLock（写锁）的复杂使用场景，实现一个缓存系统
 * 缓存系统：
 *  在程序运行过程中，有些数据我们不会经常修改，例如数据库中性别字段，但是我们却经常使用，如果每次都从数据库中获取，那么将会降低程序性能；
 *  那么我们可以在内存中分配一个区域专门存放我们第一次从数据库中拿出的数据；思路如下：我们使用Map来充当我们的缓存区域，当使用性别值时，
 *  可以先看看map中是否有值，如果有那么拿出来，如果没有那么查询数据库，并为map赋值；
 *  
 *  思路如上，但是我们要考虑多线程的问题，如果多个程序同时使用该缓存系统，有的读，有的写，那么很有可能在某一时刻，一个线程为map赋值了，
 *  但是另一个线程或多个线程会重复为map赋值；这就是多线程的并发问题，如何解决，我们采用Java5的读写锁来实现；
 *  ReentrantReadWriteLock：读锁和写锁同步，读的时候不允许写，写的时候不允许读，可以同时读；
 */
package thread02;

import java.util.HashMap;
import java.util.Map;
import java.util.concurrent.locks.ReentrantReadWriteLock;

public class ReentrantReadWriteLockTest03
{
    // 构造缓存对象（模拟存放数据的缓存）
    private final Map<String, Object> catchData = new HashMap<String, Object>();
    // 构造读写锁 
    private ReentrantReadWriteLock rwl = new ReentrantReadWriteLock();
    
    public static void main(String[] args)
    {
        ReentrantReadWriteLockTest03 rwlt = new ReentrantReadWriteLockTest03();
        System.out.println(rwlt.getData("1"));
    }
    
    public Object getData(String key)
    {
        Object value = null;
        
        try
        {
            rwl.readLock().lock();  // 当线程开始读时，首先开始加上读锁 
            
            value = catchData.get(key);  // 从缓存中获取值
            if(null == value)  // 判断是否存在值
            {
                // 缓存中不存在这个值，则从数据库中获取
                try
                {
                    rwl.readLock().unlock();  // 在开始写之前，首先要释放写锁，否则写锁无法拿到（将读取数据库的返回值赋值给value就是写操作）  
                    rwl.writeLock().lock();  // 获取写锁开始写数据
                    
                    // 这里再次判断该值是否为空；因为如果两个写线程如果都阻塞在里，当一个线程被唤醒后value的值不为null（进行了赋值操作），
                    // 当另外一个线程也被唤醒，如果不判断就会再次进行赋值操作，也就是最终进行了两次写操作，可能导致最后获取的数据不一致（因为两次查询数据库的返回值不一定一样）
                    if(null == value)
                    {
                        value = "从数据库读取出来的值";  // 将数据库返回值赋值给value，就是进行了写操作
                        catchData.put(key, value);  // 将数据放到缓存中，这样下次直接在缓存中就可以获取到值
                    }
                    
                    rwl.readLock().lock(); // 写完之后重入降级为读锁
                    // 读线程释放锁，写线程加锁；
                    // 第一个写线程开始执行任务：读取数据库数据（值为1）赋值给value，最后读线程读取并返回的value值为1；
                    // 第一个写线程任务执行完毕，释放锁；
                    // 问题来了：第一个写线程释放锁后，可能第二个写线程加锁；
                    // 第二个写线程开始执行任务，读取数据库数据（值为2）赋值给value，value的在返回之前又被改变了；
                    // 第二个写线程任务执行完毕，释放锁；
                    // 读线程加锁，读取数据，返回的value值为2；
                } 
                finally
                {
                    rwl.writeLock().unlock();  // 最后释放写锁 
                }
                
            }
            else
            {
                System.out.println("从缓存中读取到了数据：" + value);
            }
        } 
        finally
        {
            rwl.readLock().unlock();  // 释放读锁  
        }
        return value;
    }
}

ReentrantReadWriteLock与ReentrantLock的比较：
 相同点：都是显式锁，需要手动加锁解锁，都很适合高并发场景；
 不同点：
  ReentrantReadWriteLock是对ReentrantLock的复杂扩展，能适合更加复杂的业务；
  ReentrantReadWriteLock能实现一个方法中读写分离的锁的机制，而ReentrantLock加锁解锁只有一种机制；

显式锁（Lock）和隐式锁（synchronized）的比较：
ReentrantLock主要增了如下的高级功能：
1、等待可中断：
  当持有锁的线程长期不释放锁时，正在等待的线程可以选择放弃等待，改为处理其他事情，它对处理执行时间上的同步块很有帮助；而在等待由synchronized产生的互斥锁时，会一直阻塞，是不能被中断的；
2、可实现公平锁：
  多个线程在等待同一个锁时，必须按照申请锁的时间顺序排队等待；而非公平锁则不保证这点，在锁释放时，任何一个等待锁的线程都有机会获得锁；    synchronized中的锁是非公平锁，ReentrantLock默认情况下也是非公平锁，但可以通过构造方法ReentrantLock（ture）来要求使用公平锁；
3、锁可以绑定多个条件：
  ReentrantLock对象可以同时绑定多个Condition对象（名曰：条件变量或条件队列）；而在synchronized中，锁对象的wait()和notify()或notifyAll()方法可以实现一个隐含条件，但如果要和多于一个的条件关联的时候，就不得不额外地添加一个锁；而ReentrantLock则无需这么做，只需要多次调用newCondition()方法即可；而且我们还可以通过绑定Condition对象来判断当前线程通知的是哪些线程（即与Condition对象绑定在一起的其他线程）；
 其他方面的比较：
  synchronized：读写互斥、写写互斥、读读互斥（读读操作不会引发安全问题）；ReentrantReadWriteLock（读写锁）：读写互斥、写写互斥、读写不互斥；

悲观锁 与 乐观锁：
 悲观锁：顾名思义，就是很悲观，每次去拿数据的时候都认为别人会修改，所以每次在拿数据的时候都会上锁，这样别人想拿这个数据就会阻塞直到它拿到锁；传统的关系型数据库里边就用到了很多这种锁机制，比如行锁，表锁等，读锁，写锁等，都是在做操作之前先上锁；
 乐观锁：
乐观锁：顾名思义，就是很乐观，每次去拿数据的时候都认为别人不会修改，所以不会上锁，但是在更新的时候会判断一下在此期间别人有没有去更新这个数据，可以使用版本号等机制；乐观锁适用于多读的应用类型，这样可以提高吞吐量，像数据库如果提供类似于write_condition机制的其实都是提供的乐观锁；
 两种锁各有优缺点，不可认为一种好于另一种，像乐观锁适用于写比较少的情况下，即冲突真的很少发生的时候，这样可以省去了锁的开销，加大了系统的整个吞吐量；但如果经常产生冲突，上层应用会不断的进行retry，这样反倒是降低了性能，所以这种情况下用悲观锁就比较合适；

显示锁StampedLock：
 该类是一个读写锁的改进，它的思想是读写锁中读不仅不阻塞读，同时也不应该阻塞写；
 读不阻塞写的实现思路：
  在读的时候如果发生了写，则应当重读而不是在读的时候直接阻塞写！
  因为在读线程非常多而写线程比较少的情况下，写线程可能发生饥饿现象，也就是因为大量的读线程存在并且读线程都阻塞写线程，因此写线程可能几乎很少被调度成功！当读执行的时候另一个线程执行了写，则读线程发现数据不一致则执行重读即可。所以读写都存在的情况下，使用StampedLock就可以实现一种无障碍操作，即读写之间不会阻塞对方，但是写和写之间还是阻塞的！

/**
 * StampedLock的使用
 */
package thread02;

import java.util.concurrent.locks.StampedLock;

public class StampedLockTest01
{
    public static void main(String[] args)
    {
        Point point = new Point();
        point.move(1, 2);
        System.out.println(point.distanceFromOrigin());
    }
}

class Point
{
    // 一个点的x，y坐标  
    private double x, y;  
    
    /** 
     * Stamped类似一个时间戳的作用，每次写的时候对其+1来改变被操作对象的Stamped值 
     * 这样其它线程读的时候发现目标对象的Stamped改变，则执行重读 
     */
    private final StampedLock stampedLock = new StampedLock();
    
    void move(double deltaX, double deltaY) 
    {  
        /**
         * stampedLock调用writeLock和unlockWrite时候都会导致stampedLock的stamp值的变化 
         * 即每次+1，直到加到最大值，然后从0重新开始；
         */  
        long stamp = stampedLock.writeLock();  // 加写锁  
        // System.out.println(stamp);
        try 
        {  
            x += deltaX;  
            y += deltaY;  
        } 
        finally 
        {  
            stampedLock.unlockWrite(stamp);  // 释放写锁  
        }  
        
        // System.out.println("x:" + x + " y:" + y);
    }  
    
    // 乐观读锁
    double distanceFromOrigin() 
    {    
        /**
         * tryOptimisticRead是一个乐观的读，使用这种锁的读不阻塞写 
         * 每次读的时候得到一个当前的stamp值（类似时间戳的作用）
         */  
        long stamp = stampedLock.tryOptimisticRead();  // 获得一个乐观锁 
  
        //这里就是读操作，读取x和y，因为读取x时，y可能被写了新的值，所以下面需要判断  
        double currentX = x, currentY = y;  // 将两个字段读入本地局部变量
  
        /**
         * 如果读取的时候发生了写，则stampedLock的stamp属性值会变化，此时需要重读， 
         * 在重读的时候需要加读锁（并且重读时使用的应当是悲观的读锁，即阻塞写的读锁） 
         * 当然重读的时候还可以使用tryOptimisticRead，此时需要结合循环了，即类似CAS方式 
         * 读锁又重新返回一个stampe值
         */  
        if (!stampedLock.validate(stamp))  // 检查发出乐观读锁后同时是否有其他写锁发生
        {  
            stamp = stampedLock.readLock();  // 如果没有，我们再次获得一个读悲观锁
            try 
            {  
                currentX = x;  // 将两个字段读入本地局部变量
                currentY = y;  // 将两个字段读入本地局部变量
            } 
            finally 
            {  
                stampedLock.unlockRead(stamp);  // 释放读锁  
            }  
        }  
        
        // System.out.println("x:" + x + " y:" + y);
        //读锁验证成功后才执行计算，即读的时候没有发生写  
        return Math.sqrt(currentX * currentX + currentY * currentY);  
    }  
    
    // 悲观读锁
    void moveIfAtOrigin(double newX, double newY) 
    {     
        long stamp = stampedLock.readLock();
        try 
        {
          while (x == 0.0 && y == 0.0)  // 循环，检查当前状态是否符合
          { 
            long ws = stampedLock.tryConvertToWriteLock(stamp);  // 将读锁转为写锁
            if (ws != 0L)  // 这是确认转为写锁是否成功
            { 
              stamp = ws;  // 如果成功，替换票据
              x = newX;  // 进行状态改变
              y = newY;  // 进行状态改变
              break;
            }
            else  // 如果不能成功转换为写锁
            { 
              stampedLock.unlockRead(stamp);  // 我们显式释放读锁
              stamp = stampedLock.writeLock();  // 显式直接进行写锁，然后再通过循环再试
            }
          }
        } 
        finally 
        {
            stampedLock.unlock(stamp);  // 释放读锁或写锁
        }
     }
}

死锁：
 在两段不同的逻辑都在等待对方的锁释放才能继续往下工作时，这个时候就会产生死锁；

/**
 * 死锁
 */
package thread02;

class Count11
{
    private byte[] lock1 = new byte[1];
    private byte[] lock2 = new byte[2];
    
    private int num = 0;
    
    public void add1()
    {
        synchronized (lock1)
        {
            try
            {
                Thread.sleep(1001);  // 模拟干活
            } 
            catch (InterruptedException e)
            {
                e.printStackTrace();
            }
            
            synchronized (lock2)  // 产生死锁，一直在等待lock2对象释放锁
            {
                num += 1;
            }
            
            System.out.println(Thread.currentThread().getName() + " - " + num);
        }
    }
    
    public void add2()
    {
        synchronized (lock2)
        {
            try
            {
                Thread.sleep(1001);
            } 
            catch (InterruptedException e)
            {
                e.printStackTrace();
            }
            
            synchronized (lock1)  // 产生死锁，一直等待lock1对象释放锁
            {
                num += 1;
            }
            
            System.out.println(Thread.currentThread().getName() + " - " + num);
        }
    }
}

public class DeadLockTest01
{
    public static void main(String[] args)
    {
        Count11 count = new Count11();
        
        ThreadA threadA = new ThreadA(count);
        Thread t1 = new Thread(threadA);
        t1.setName("线程A");
        
        ThreadB threadB = new ThreadB(count);
        Thread t2 = new Thread(threadB);
        t2.setName("线程B");
    }
    
}

class ThreadA implements Runnable
{
    private Count11 count;
    
    public ThreadA(Count11 count)
    {
        this.count = count;
    }
    
    @Override
    public void run()
    {
        count.add1();
    }
}

class ThreadB implements Runnable
{
    private Count11 count;
    
    public ThreadB(Count11 count)
    {
        this.count = count;
    }
    
    @Override
    public void run()
    {
        count.add2();
    }
}

volatile：
 表面意思：易变的，不稳定的；
 作用：修饰变量；告诉编译器，凡是被该关键字声明的变量都是易变的，不稳定的；所以不要试图对该变量使用缓存等优化机制，而应当每次都从它的内存地址中去读取值；
 特性：
  使用volatile标记的变量在读取或写入时不需要使用锁，这将减少产生死锁的概率，使代码保持整洁；
  每次读取volatile的变量都要从它的内存地址中读取，但并不是每次修改完volatile的变量后都要立刻将它的值写回内存；也就是说volatile只提供内存可见性，而没有提供原子性；所以使用这个关键字做高并发的安全机制是不可靠的；
 适用场景：
  最好是那种只有一个线程修改变量，多个线程读取该变量的地方；也就是对内存可见性要求高，而对原子性要求低的地方；
 volatile与加锁机制的主要区别：
  加锁机制既可以保证可见性又可以确保原子性；而volatile变量只能保证可见性；

atomic：
 详述：
  atomic是不会阻塞线程（或者说只是在硬件级别上阻塞了），线程安全的加强版的volatile原子操作；
  java.util.concurrent.atomic包里，多了一批原子操作，主要用于高并发环境下的高效程序处理；

/**
 * 原子操作
 */
package thread02;

import java.util.concurrent.atomic.AtomicInteger;

public class AtomicIntegerTest01
{
    public static void main(String[] args)
    {
        AtomicInteger ai = new AtomicInteger(0);
        
        // 获取当前的值
        System.out.println(ai.get());
        System.out.println("--------------");
        
        // 取当前的值，并设置新的值
        System.out.println(ai.getAndSet(5));
        System.out.println(ai.get());  // 设置新值之后的当前值
        System.out.println("--------------");
        
        // 获取当前的值，并自增
        System.out.println(ai.getAndIncrement());
        System.out.println(ai.get());  // 自增之后的当前值
        System.out.println("--------------");
        
        // 获取当前的值，并自减
        System.out.println(ai.getAndDecrement());
        System.out.println(ai.get());  // 自减之后的当前值
        System.out.println("--------------");
        
        // 获取当前的值，并加上预期的值
        System.out.println(ai.getAndAdd(3));
        System.out.println(ai.get());  // 加上预期值之后的当前值
        System.out.println("--------------");
        
    }
}

单例：

/**
 * 单例模式第一种写法：线程不安全的，不正确的写法
 */
package thread02.singleton;

public class Singleton01
{
    private static Singleton01 instance;
    
    private Singleton01()
    {
        
    }
    
    public static Singleton01 getSingleton()
    {
        if(instance == null)
        {
            instance = new Singleton01();
        }
        
        return instance;
    }
}

/**
 * 单例模式第二种写法：线程安全，但是高并发性能不是很高
 */
package thread02.singleton;

public class Singleton02
{
    private static Singleton02 instance;
    
    private Singleton02()
    {
        
    }
    
    public static synchronized Singleton02 getSingleton()
    {
        if(instance == null)
        {
            instance = new Singleton02();
        }
        
        return instance;
    }
}

/**
 * 单例模式第三种写法：线程安全，性能又高，这种写法最为常用
 */
package thread02.singleton;

public class Singleton03
{
    private static Singleton03 instance;
    private static byte[] lock = new byte[0];
    
    private Singleton03()
    {
        
    }
    
    public static Singleton03 getSingleton()
    {
        if(instance == null)
        {
            synchronized (lock)
            {
                if(instance == null)
                {
                    instance = new Singleton03();
                }
            }
        }
        
        return instance;
    }
}

/**
 * 单例模式第四种写法：线程安全，性能又高，也是最为常用的
 */
package thread02.singleton;

import java.util.concurrent.locks.ReentrantLock;

public class Singleton04
{
    private static Singleton04 instance;
    private static ReentrantLock lock = new ReentrantLock();
    
    private Singleton04()
    {
        
    }
    
    public static Singleton04 getSingleton()
    {
        if(instance == null)
        {
            lock.lock();
            
            if(instance == null)
            {
                instance = new Singleton04();
            }
            
            lock.unlock();
        }
        
        return instance;
    }
}