Java多线程同步的方法

一 synchronized关键字

1.synchronized实现原理： ---基于对象监视器（锁）

java中所有对象都自动含有单一的锁，JVM负责跟踪对象被加锁的次数。如果一个对象被解锁，其计数变为0。在任务（线程）第一次给对象加锁的时候， 计数变为1。每当这个相同的任务（线程）在此对象上获得锁时，计数会递增。只有首先获得锁的任务（线程）才能继续获取该对象上的多个锁。每当任务离开时，计数递减，当计数为0的时候，锁被完全释放。

Java中每个对象或者类都有一把锁与之相关联，对于对象来说，监视的是这个对象的实例变量，对于类来说，监视的是类变量（一个类本身是类Class的对象，所以与类关联的锁也是对象锁）

一个线程执行互斥代码过程如下：

1. 获得同步锁；

2. 清空工作内存；

3. 从主内存拷贝对象副本到工作内存；

4. 执行代码(计算或者输出等)；

5. 刷新主内存数据；

6. 释放同步锁。

所以，synchronized既保证了多线程的并发有序性，又保证了多线程的内存可见性。

2.使用方式：

synchronized关键字使用方式有两种：synchronized方法和synchronized块。这两种监视区域都和一个引入对象相关联，当到达这个监视区域时，JVM就会锁住这个引用对象，当离开时会释放这个引用对象上的锁（有异常退出时，JVM会释放锁）。对象锁是JVM内部机制，只需要编写同步方法或者同步块即可，操作监视区域时JVM会自动获取锁或者释放锁。

　　当synchronized作用在方法上时，锁住的便是对象实例（this）；当作用在静态方法时锁住的便是对象对应的Class实例(类)。

二 JavaSE5.0中新增了一个java.util.concurrent包来支持同步，ReentrantLock类。

1.ReentrantLock类

ReenreantLock类的常用方法有：
ReentrantLock() : 创建一个ReentrantLock实例
lock() : 获得锁
unlock() : 释放锁
注：ReentrantLock()还有一个可以创建公平锁的构造方法，但由于能大幅度降低程序运行效率，不推荐使用

两种多线程同步机制的代码实现：

package com.test1;

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

public class ThreadTest {

    public ThreadTest(){
        Bank b=new Bank();
        Thread t1=new Thread(b);
        Thread t2=new Thread(b);
        Thread t3=new Thread(b);
        t1.start();
        t2.start();
        t3.start();
    }

    public static void main(String[] args) {

        ThreadTest threadTest=new ThreadTest();

    }

}

class Bank implements Runnable{

        private int account=100;

        //线程同步机制1：线程同步方法 synchronized 或者 synchronized{} 修饰共享变量的执行 语句块
        public synchronized void minus_syn(){
                    account--;
                    System.out.println(Thread.currentThread().getName()+" account="+account);
        }

        //线程同步机制2：使用 重入锁 实现线程同步
        /**
         *
    在JavaSE5.0中新增了一个java.util.concurrent包来支持同步。   ReentrantLock类是可重入、互斥、实现了Lock接口的锁，
    它与使用synchronized方法和快具有相同的基本行为和语义，并且扩展了其能力
    ReenreantLock类的常用方法有：
        ReentrantLock() : 创建一个ReentrantLock实例
        lock() : 获得锁
        unlock() : 释放锁
    注：ReentrantLock()还有一个可以创建公平锁的构造方法，但由于能大幅度降低程序运行效率，不推荐使用
         */
        private Lock lock = new ReentrantLock();
        public  void minus_lock(){
               lock.lock();
                try{
                    account--;
                    System.out.println(Thread.currentThread().getName()+" account="+account);
                }finally{
                    lock.unlock();
                }
        }

        @Override
        public void run() {
            // TODO Auto-generated method stub
            while(true){

                try {
                    Thread.sleep(10);
                } catch (InterruptedException e) {
                    // TODO Auto-generated catch block
                    e.printStackTrace();
                }

            /*    synchronized 同步块
             *
             * synchronized (this) {

                    if(account>0){
                        account-=1;
                        System.out.println(Thread.currentThread().getName()+" account="+account);
                        }
                    else break;
                }*/

                /*synchronized 方法
                 *
                 * minus_syn();
                if(account<0) break;*/

                //   ReentrantLock类 lock
                minus_lock();
                if(account<0) break;

            }
        }
    }

(转！)总结：

1、synchronized关键字的作用域有二种： 
1）是某个对象实例内，synchronized aMethod(){}可以防止多个线程同时访问这个对象的synchronized方法（如果一个对象有多个synchronized方法，只要一个线程访问了其中的一个synchronized方法，其它线程不能同时访问这个对象中任何一个synchronized方法）。这时，不同的对象实例的synchronized方法是不相干扰的。也就是说，其它线程照样可以同时访问相同类的另一个对象实例中的synchronized方法； 
2）是某个类的范围，synchronized static aStaticMethod{}防止多个线程同时访问这个类中的synchronized static 方法。它可以对类的所有对象实例起作用。

2、除了方法前用synchronized关键字，synchronized关键字还可以用于方法中的某个区块中，表示只对这个区块的资源实行互斥访问。用法是: synchronized(this){/*区块*/}，它的作用域是当前对象；

3、synchronized关键字是不能继承的，也就是说，基类的方法synchronized f(){} 在继承类中并不自动是synchronized f(){}，而是变成了f(){}。继承类需要你显式的指定它的某个方法为synchronized方法；

Java语言的关键字，当它用来修饰一个方法或者一个代码块的时候，能够保证在同一时刻最多只有一个线程执行该段代码。

一、当两个并发线程访问同一个对象object中的这个synchronized(this)同步代码块时，一个时间内只能有一个线程得到执行。另一个线程必须等待当前线程执行完这个代码块以后才能执行该代码块。

二、然而，当一个线程访问object的一个synchronized(this)同步代码块时，另一个线程仍然可以访问该object中的非synchronized(this)同步代码块。

三、尤其关键的是，当一个线程访问object的一个synchronized(this)同步代码块时，其他线程对object中所有其它synchronized(this)同步代码块的访问将被阻塞。

看到网上有些说volatile和ThreadLocal也能用于线程同步，说法不准确！

后面谈谈java关键字volatile和ThreadLocal类