线程同步的方法

转自：https://www.cnblogs.com/XHJT/p/3897440.html

一、什么是线程同步

线程同步就是线程排队，避免线程“同步”

二、为什么需要线程同步

在java多线程并发控制时，当多个线程同时操作共享资源（共享、变量）时，会导致数据不准确，相互之间产生冲突。因此加入同步锁，在该线程没有完成操作之前，不能被其他线程调用，从而保证了该变量的唯一性和准确性。

三、实现方式

1、同步方法

使用synchronized关键字修饰的方法。 由于java的每个对象都有一个内置锁，当用此关键字修饰方法时，内置锁会保护整个方法。在调用该方法前，需要获得内置锁，否则就处于阻塞状态。

//存钱      public  synchronized void addMoney(int money){          count +=money;          System.out.println(System.currentTimeMillis()+"存进："+money);      } 

   注： synchronized关键字也可以修饰静态方法，此时如果调用该静态方法，将会锁住整个类

2、同步代码块

即有synchronized关键字修饰的语句块。被该关键字修饰的语句块会自动被加上内置锁，从而实现同步。

注：同步是一种高开销的操作，因此应该尽量减少同步的内容。通常没有必要同步整个方法，使用synchronized代码块同步关键代码即可。

线程在执行同步方法时是具有排它性的。当任意一个线程进入到一个对象的任意一个同步方法时，这个对象的所有同步方法都被锁定了，在此期间，其他任何线程都不能访问这个对象的任意一个同步方法，直到这个线程执行完它所调用的同步方法并从中退出，从而导致它释放了该对象的同步锁之后。在一个对象被某个线程锁定之后，其他线程是可以访问这个对象的所有非同步方法的。

同步块：同步块是通过锁定一个指定的对象，来对同步块中包含的代码进行同步；而同步方法是对这个方法块里的代码进行同步，而这种情况下锁定的对象就是同步方法所属的主体对象自身。如果这个方法是静态同步方法呢？那么线程锁定的就不是这个类的对象了，也不是这个类自身，而是这个类对应的java.lang.Class类型的对象。同步方法和同步块之间的相互制约只限于同一个对象之间，所以静态同步方法只受它所属类的其它静态同步方法的制约，而跟这个类的实例（对象）没有关系。

如果一个对象既有同步方法，又有同步块，那么当其中任意一个同步方法或者同步块被某个线程执行时，这个对象就被锁定了，其他线程无法在此时访问这个对象的同步方法，也不能执行同步块。

//存钱      public   void addMoney(int money){                    synchronized (this) {              count +=money;          }          System.out.println(System.currentTimeMillis()+"存进："+money);      }  

3、使用特殊域变量（volatile）实现线程同步

　1）保证了不同线程对这个变量进行操作时的可见性，即一个线程修改了某个变量的值，这新值对其他线程来说是立即可见的。

　2）禁止进行指令重排序。

每次要线程要访问volatile修饰的变量时都是从内存中读取，而不是存缓存当中读取，因此每个线程访问到的变量值都是一样的。这样就保证了同步。

 private volatile int count = 0;// 账户余额        // 存钱      public void addMoney(int money) {            count += money;          System.out.println(System.currentTimeMillis() + "存进：" + money);      }    

4、wait和notify

wait():使一个线程处于等待状态，并且释放所持有的对象的lock。

sleep():使一个正在运行的线程处于睡眠状态，是一个静态方法，调用此方法要捕捉InterruptedException异常。
notify():唤醒一个处于等待状态的线程，注意的是在调用此方法的时候，并不能确切的唤醒某一个等待状态的线程，而是由JVM确定唤醒哪个线程，而且不是按优先级。
notifyAll():唤醒所有处入等待状态的线程，注意并不是给所有唤醒线程一个对象的锁，而是让它们竞争。

5、使用重入锁（ReentrantLock）实现线程同步

ReentrantLock类是可重入、互斥、实现了Lock接口的锁， 它与使用synchronized方法和快具有相同的基本行为和语义，并且扩展了其能力。

//需要声明这个锁      private Lock lock = new ReentrantLock();        // 存钱      public void addMoney(int money) {          lock.lock();//上锁          try{          count += money;          System.out.println(System.currentTimeMillis() + "存进：" + money);                    }finally{              lock.unlock();//解锁          }      }  

6、使用局部变量实现线程同步

  如果使用ThreadLocal管理变量，则每一个使用该变量的线程都获得该变量的副本，
    副本之间相互独立，这样每一个线程都可以随意修改自己的变量副本，而不会对其他线程产生影响。

 

    ThreadLocal 类的常用方法

 

    ThreadLocal() : 创建一个线程本地变量
    get() : 返回此线程局部变量的当前线程副本中的值
    initialValue() : 返回此线程局部变量的当前线程的"初始值"
    set(T value) : 将此线程局部变量的当前线程副本中的值设置为value

 //使用ThreadLocal类管理共享变量account            private static ThreadLocal<Integer> account = new ThreadLocal<Integer>(){                @Override                protected Integer initialValue(){                    return 100;                }            };            public void save(int money){                account.set(account.get()+money);            }            public int getAccount(){                return account.get();            }

7、使用阻塞队列实现线程同步

前面几种同步方式都是在底层实现的线程同步，但是我们在实际开发当中，应当尽量远离底层结构。 
    使用javaSE5.0版本中新增的java.util.concurrent包将有助于简化开发。 
    本小节主要是使用LinkedBlockingQueue<E>来实现线程的同步 
    LinkedBlockingQueue<E>是一个基于已连接节点的，范围任意的blocking queue。 
    队列是先进先出的顺序（FIFO），关于队列以后会详细讲解~ 
    
   LinkedBlockingQueue 类常用方法 
    LinkedBlockingQueue() : 创建一个容量为Integer.MAX_VALUE的LinkedBlockingQueue 
    put(E e) : 在队尾添加一个元素，如果队列满则阻塞 
    size() : 返回队列中的元素个数 
    take() : 移除并返回队头元素，如果队列空则阻塞 
   

public class BlockingSynchronizedThread {    /**     * 定义一个阻塞队列用来存储生产出来的商品     */    private LinkedBlockingQueue<Integer> queue = new LinkedBlockingQueue<Integer>();    /**     * 定义生产商品个数     */    private static final int size = 10;    /**     * 定义启动线程的标志，为0时，启动生产商品的线程；为1时，启动消费商品的线程     */    private int flag = 0;    private class LinkBlockThread implements Runnable {        @Override        public void run() {            int new_flag = flag++;            System.out.println("启动线程 " + new_flag);            if (new_flag == 0) {                for (int i = 0; i < size; i++) {                    int b = new Random().nextInt(255);                    System.out.println("生产商品：" + b + "号");                    try {                        queue.put(b);                    } catch (InterruptedException e) {                        // TODO Auto-generated catch block                        e.printStackTrace();                    }                    System.out.println("仓库中还有商品：" + queue.size() + "个");                    try {                        Thread.sleep(100);                    } catch (InterruptedException e) {                        // TODO Auto-generated catch block                        e.printStackTrace();                    }                }            } else {                for (int i = 0; i < size / 2; i++) {                    try {                        int n = queue.take();                        System.out.println("消费者买去了" + n + "号商品");                    } catch (InterruptedException e) {                        // TODO Auto-generated catch block                        e.printStackTrace();                    }                    System.out.println("仓库中还有商品：" + queue.size() + "个");                    try {                        Thread.sleep(100);                    } catch (Exception e) {                        // TODO: handle exception                    }                }            }        }    }    public static void main(String[] args) {        BlockingSynchronizedThread bst = new BlockingSynchronizedThread();        LinkBlockThread lbt = bst.new LinkBlockThread();        Thread thread1 = new Thread(lbt);        Thread thread2 = new Thread(lbt);        thread1.start();        thread2.start();    }}

BlockingQueue<E>定义了阻塞队列的常用方法，尤其是三种添加元素的方法，我们要多加注意，当队列满时：

　　add()方法会抛出异常

　　offer()方法返回false

　　put()方法会阻塞

8、使用原子变量实现线程同步

需要使用线程同步的根本原因在于对普通变量的操作不是原子的。

那么什么是原子操作呢？
原子操作就是指将读取变量值、修改变量值、保存变量值看成一个整体来操作
即-这几种行为要么同时完成，要么都不完成。

在java的util.concurrent.atomic包中提供了创建了原子类型变量的工具类，
使用该类可以简化线程同步。

其中AtomicInteger 表可以用原子方式更新int的值，可用在应用程序中(如以原子方式增加的计数器)，
但不能用于替换Integer；可扩展Number，允许那些处理机遇数字类的工具和实用工具进行统一访问。

AtomicInteger类常用方法：
AtomicInteger(int initialValue) : 创建具有给定初始值的新的AtomicInteger
addAddGet(int dalta) : 以原子方式将给定值与当前值相加
get() : 获取当前值

private AtomicInteger account = new AtomicInteger(100);        public AtomicInteger getAccount() {            return account;        }        public void save(int money) {            account.addAndGet(money);        }

补充--原子操作主要有：
　　对于引用变量和大多数原始变量(long和double除外)的读写操作；
　　对于所有使用volatile修饰的变量(包括long和double)的读写操作。