java中线程同步的几种方法

线程同步主要有以下种方法(示例中是实现计数的功能)：

十年的恭城网站建设经验，针对设计、前端、开发、售后、文案、推广等六对一服务，响应快，48小时及时工作处理。全网整合营销推广的优势是能够根据用户设备显示端的尺寸不同，自动调整恭城建站的显示方式，使网站能够适用不同显示终端，在浏览器中调整网站的宽度，无论在任何一种浏览器上浏览网站，都能展现优雅布局与设计，从而大程度地提升浏览体验。成都创新互联从事“恭城网站设计”,“恭城网站推广”以来，每个客户项目都认真落实执行。

1、同步方法，即使用synchronized关键字修饰方法，例如：

public synchronized void add(int c){...}

2、同步代码块，即有synchronized关键字修饰的语句块，例如：

public void addAndGet(int c){

synchronized(this){

count += c;

}

}

3、使用特殊域变量(volatile)实现线程同步，该方法不能保证绝对的同步。

例如：private volatile int count = 0;

4、使用锁实现线程同步，例如：

private Lock lock = new ReentrantLock();

public void add(int c) {  

lock.lock();//上锁  

try{  

count += c;  

}finally{  

lock.unlock();//解锁  

}  

}

5、使用原子变量实现线程同步，在java的util.concurrent.atomic包中提供了创建了原子类型变量的工具类，例如：

private AtomicInteger count= new AtomicInteger(1);

public void add(int c) {

count.addAndGet(c);

}

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

ThreadLocal 类的常用方法

new ThreadLocalT() : 创建一个线程本地变量

get() : 返回此线程局部变量的当前线程副本中的值

initialValue() : 返回此线程局部变量的当前线程的"初始值"

set(T value) : 将此线程局部变量的当前线程副本中的值设置为value

示例代码：

private static ThreadLocalInteger count= new ThreadLocalInteger(){

@Override

protected Integer initialValue(){ 

return 1;

}

};            

public void add(int c){

count.set(count.get() + c);

}

7、使用阻塞队列实现，例如LinkedBlockingQueue，具体使用可百度LinkedBlockingQueue的用法或查看java文档。

Java多线程初学者指南（10）：使用Synchronized关键字同步类方法

要想解决 脏数据 的问题 最简单的方法就是使用synchronized关键字来使run方法同步 代码如下

public synchronized void run(){     }

从上面的代码可以看出 只要在void和public之间加上synchronized关键字 就可以使run方法同步 也就是说 对于同一个Java类的对象实例 run方法同时只能被一个线程调用 并当前的run执行完后 才能被其他的线程调用 即使当前线程执行到了run方法中的yield方法 也只是暂停了一下 由于其他线程无法执行run方法 因此 最终还是会由当前的线程来继续执行 先看看下面的代码

sychronized关键字只和一个对象实例绑定

class Test  {        public synchronized void method()       {                   }  }     public class Sync implements Runnable  {       private Test test;       public void run()       {            thod();       }       public Sync(Test test)       {           this test = test;       }       public static void main(String[] args) throws Exception       {           Test test  =  new Test();           Test test  =  new Test();           Sync sync  = new Sync(test );           Sync sync  = new Sync(test );           new Thread(sync ) start();           new Thread(sync ) start();        }   }

在Test类中的method方法是同步的 但上面的代码建立了两个Test类的实例 因此 test 和test 的method方法是分别执行的 要想让method同步 必须在建立Sync类的实例时向它的构造方法中传入同一个Test类的实例 如下面的代码所示

Sync sync  = new Sync(test );

不仅可以使用synchronized来同步非静态方法 也可以使用synchronized来同步静态方法 如可以按如下方式来定义method方法

class Test {    public static synchronized void method() {   }}

建立Test类的对象实例如下

Test test = new Test();

对于静态方法来说 只要加上了synchronized关键字 这个方法就是同步的 无论是使用thod（） 还是使用thod（）来调用method方法 method都是同步的 并不存在非静态方法的多个实例的问题

在 种设计模式中的单件（Singleton）模式如果按传统的方法设计 也是线程不安全的 下面的代码是一个线程不安全的单件模式

package test;// 线程安全的Singleton模式class Singleton{    private static Singleton sample;    private Singleton()    {    }    public static Singleton getInstance()    {        if (sample == null)        {            Thread yield(); // 为了放大Singleton模式的线程不安全性            sample = new Singleton();        }        return sample;    }}public class MyThread extends Thread{    public void run()    {        Singleton singleton = Singleton getInstance();        System out println(singleton hashCode());    }    public static void main(String[] args)    {        Thread threads[] = new Thread[ ];        for (int i =  ; i  threads length; i++)            threads[i] = new MyThread();        for (int i =  ; i  threads length; i++)            threads[i] start();    }}

在上面的代码调用yield方法是为了使单件模式的线程不安全性表现出来 如果将这行去掉 上面的实现仍然是线程不安全的 只是出现的可能性小得多

程序的运行结果如下

上面的运行结果可能在不同的运行环境上有所有同 但一般这五行输出不会完全相同 从这个输出结果可以看出 通过getInstance方法得到的对象实例是五个 而不是我们期望的一个 这是因为当一个线程执行了Thread yield（）后 就将CPU资源交给了另外一个线程 由于在线程之间切换时并未执行到创建Singleton对象实例的语句 因此 这几个线程都通过了if判断 所以 就会产生了建立五个对象实例的情况（可能创建的是四个或三个对象实例 这取决于有多少个线程在创建Singleton对象之前通过了if判断 每次运行时可能结果会不一样）

要想使上面的单件模式变成线程安全的 只要为getInstance加上synchronized关键字即可 代码如下

public static synchronized Singleton getInstance() {   }

当然 还有更简单的方法 就是在定义Singleton变量时就建立Singleton对象 代码如下

private static final Singleton sample = new Singleton();

然后在getInstance方法中直接将sample返回即可 这种方式虽然简单 但不知在getInstance方法中创建Singleton对象灵活 读者可以根据具体的需求选择使用不同的方法来实现单件模式

在使用synchronized关键字时有以下四点需要注意

synchronized关键字不能继承

虽然可以使用synchronized来定义方法 但synchronized并不属于方法定义的一部分 因此 synchronized关键字不能被继承 如果在父类中的某个方法使用了synchronized关键字 而在子类中覆盖了这个方法 在子类中的这个方法默认情况下并不是同步的 而必须显式地在子类的这个方法中加上synchronized关键字才可以 当然 还可以在子类方法中调用父类中相应的方法 这样虽然子类中的方法不是同步的 但子类调用了父类的同步方法 因此 子类的方法也就相当于同步了 这两种方式的例子代码如下

在子类方法中加上synchronized关键字

class Parent{    public synchronized void method() {   }}class Child extends Parent{    public synchronized void method() {   }}

在子类方法中调用父类的同步方法

class Parent{    public synchronized void method() {   }}class Child extends Parent{    public void method() { thod();   }}

在定义接口方法时不能使用synchronized关键字

构造方法不能使用synchronized关键字 但可以使用下节要讨论的synchronized块来进行同步

synchronized可以自由放置

在前面的例子中使用都是将synchronized关键字放在方法的返回类型前面 但这并不是synchronized可放置唯一位置 在非静态方法中 synchronized还可以放在方法定义的最前面 在静态方法中 synchronized可以放在static的前面 代码如下

public synchronized void method();synchronized public void method();public static synchronized void method();public synchronized static void method();synchronized public static void method();

但要注意 synchronized不能放在方法返回类型的后面 如下面的代码是错误的

public void synchronized method();public static void synchronized method();

synchronized关键字只能用来同步方法 不能用来同步类变量 如下面的代码也是错误的

public synchronized int n =  ;public static synchronized int n =  ;

虽然使用synchronized关键字同步方法是最安全的同步方式 但大量使用synchronized关键字会造成不必要的资源消耗以及性能损失 虽然从表面上看synchronized锁定的是一个方法 但实际上synchronized锁定的是一个类 也就是说 如果在非静态方法method 和method 定义时都使用了synchronized 在method 未执行完之前 method 是不能执行的 静态方法和非静态方法的情况类似 但静态和非静态方法不会互相影响 看看如下的代码

package test;public class MyThread  extends Thread{    public String methodName;    public static void method(String s)    {        System out println(s);        while (true)            ;    }    public synchronized void method ()    {        method( 非静态的method 方法 );    }    public synchronized void method ()    {        method( 非静态的method 方法 );    }    public static synchronized void method ()    {        method( 静态的method 方法 );    }    public static synchronized void method ()    {        method( 静态的method 方法 );    }    public void run()    {        try        {            getClass() getMethod(methodName) invoke(this);        }        catch (Exception e)        {        }    }    public static void main(String[] args) throws Exception    {        MyThread  myThread  = new MyThread ();        for (int i =  ; i =  ; i++)        {            thodName =  method  + String valueOf(i);            new Thread(myThread ) start();            sleep( );        }    }}

运行结果如下

非静态的method 方法静态的method 方法

lishixinzhi/Article/program/Java/gj/201311/27526

初学Java多线程：使用Synchronized块同步方法

synchronized关键字有两种用法 第一种就是在《使用Synchronized关键字同步类方法》一文中所介绍的直接用在方法的定义中 另外一种就是synchronized块 我们不仅可以通过synchronized块来同步一个对象变量 也可以使用synchronized块来同步类中的静态方法和非静态方法

synchronized块的语法如下

public void method()

{

… …

synchronized(表达式)

{

… …

}

}

一 非静态类方法的同步

从《使用Synchronized关键字同步类方法》一文中我们知道使用synchronized关键字来定义方法就会锁定类中所有使用synchronzied关键字定义的静态方法或非静态方法 但这并不好理解 而如果使用synchronized块来达到同样的效果 就不难理解为什么会产生这种效果了 如果想使用synchronized块来锁定类中所有的同步非静态方法 需要使用this做为synchronized块的参数传入synchronized块国 代码如下

通过synchronized块同步非静态方法

public class SyncBlock

{

public void method ()

{

synchronized(this)  // 相当于对method 方法使用synchronized关键字

{

… …

}

}

public void method ()

{

synchronized(this)  // 相当于对method 方法使用synchronized关键字

{

… …

}

}

public synchronized void method ()

{

… …

}

}

在上面的代码中的method 和method 方法中使用了synchronized块 而第 行的method 方法仍然使用synchronized关键字来定义方法 在使用同一个SyncBlock类实例时 这三个方法只要有一个正在执行 其他两个方法就会因未获得同步锁而被阻塞 在使用synchronized块时要想达到和synchronized关键字同样的效果 必须将所有的代码都写在synchronized块中 否则 将无法使当前方法中的所有代码和其他的方法同步

除了使用this做为synchronized块的参数外 还可以使用SyncBlock this作为synchronized块的参数来达到同样的效果

在内类（InnerClass）的方法中使用synchronized块来时 this只表示内类 和外类(OuterClass)没有关系 但内类的非静态方法可以和外类的非静态方法同步 如在内类InnerClass中加一个method 方法 并使method 方法和SyncBlock的三个方法同步 代码如下

使内类的非静态方法和外类的非静态方法同步

public class SyncBlock

{

… …

class InnerClass

{

public void method ()

{

synchronized(SyncBlock this)

{

… …

}

}

}

… …

}

在上面SyncBlock类的新版本中 InnerClass类的method 方法和SyncBlock类的其他三个方法同步 因此 method method method 和method 四个方法在同一时间只能有一个方法执行

Synchronized块不管是正常执行完 还是因为程序出错而异常退出synchronized块 当前的synchronized块所持有的同步锁都会自动释放 因此 在使用synchronized块时不必担心同步锁的释放问题

二 静态类方法的同步

由于在调用静态方法时 对象实例不一定被创建 因此 就不能使用this来同步静态方法 而必须使用Class对象来同步静态方法 代码如下

通过synchronized块同步静态方法

public class StaticSyncBlock

{

public static void method ()

{

synchronized(StaticSyncBlock class)

{

… …

}

}

public static synchronized void method ()

{

… …

}

}

在同步静态方法时可以使用类的静态字段class来得到Class对象 在上例中method 和method 方法同时只能有一个方法执行 除了使用class字段得到Class对象外 还可以使用实例的getClass方法来得到Class对象 上例中的代码可以修改如下

使用getClass方法得到Class对象

public class StaticSyncBlock

{

public static StaticSyncBlock instance;

public StaticSyncBlock()

{

instance = this;

}

public static void method ()

{

synchronized(instance getClass())

{

}

}

}

在上面代码中通过一个public的静态instance得到一个StaticSyncBlock类的实例 并通过这个实例的getClass方法得到了Class对象（一个类的所有实例通过getClass方法得到的都是同一个Class对象 因此 调用任何一个实例的getClass方法都可以） 我们还可以通过Class对象使不同类的静态方法同步 如Test类的静态方法method和StaticSyncBlock类的两个静态方法同步 代码如下

Test类的method方法和StaticSyncBlock类的method method 方法同步

public class Test

{

public static void method()

{

synchronized(StaticSyncBlock class)

{

}

}

}

lishixinzhi/Article/program/Java/gj/201311/27374

java多线程有几种实现方法？线程之间如何同步

一、为什么要线程同步

因为当我们有多个线程要同时访问一个变量或对象时，如果这些线程中既有读又有写操作时，就会导致变量值或对象的状态出现混乱，从而导致程序异常。举个例子，如果一个银行账户同时被两个线程操作，一个取100块，一个存钱100块。假设账户原本有0块，如果取钱线程和存钱线程同时发生，会出现什么结果呢？取钱不成功，账户余额是100.取钱成功了，账户余额是0.那到底是哪个呢？很难说清楚。因此多线程同步就是要解决这个问题。

二、不同步时的代码

Bank.Java

package threadTest;

/**

* @author ww

*

*/

public class Bank {

private int count =0;//账户余额

//存钱

public  void addMoney(int money){

count +=money;

System.out.println(System.currentTimeMillis()+"存进："+money);

}

//取钱

public  void subMoney(int money){

if(count-money  0){

System.out.println("余额不足");

return;

}

count -=money;

System.out.println(+System.currentTimeMillis()+"取出："+money);

}

//查询

public void lookMoney(){

System.out.println("账户余额："+count);

}

}

SyncThreadTest.java

package threadTest;

public class SyncThreadTest {

public static void main(String args[]){

final Bank bank=new Bank();

Thread tadd=new Thread(new Runnable() {

@Override

public void run() {

// TODO Auto-generated method stub

while(true){

try {

Thread.sleep(1000);

} catch (InterruptedException e) {

// TODO Auto-generated catch block

e.printStackTrace();

}

bank.addMoney(100);

bank.lookMoney();

System.out.println("\n");

}

}

});

Thread tsub = new Thread(new Runnable() {

@Override

public void run() {

// TODO Auto-generated method stub

while(true){

bank.subMoney(100);

bank.lookMoney();

System.out.println("\n");

try {

Thread.sleep(1000);

} catch (InterruptedException e) {

// TODO Auto-generated catch block

e.printStackTrace();

}

}

}

});

tsub.start();

tadd.start();

}

}

余额不足

账户余额：0

余额不足

账户余额：100

1441790503354存进：100

账户余额：100

1441790504354存进：100

账户余额：100

1441790504354取出：100

账户余额：100

1441790505355存进：100

账户余额：100

1441790505355取出：100

账户余额：100

三、使用同步时的代码

（1）同步方法：

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

修改后的Bank.java

package threadTest;

/**

* @author ww

*

*/

public class Bank {

private int count =0;//账户余额

//存钱

public  synchronized void addMoney(int money){

count +=money;

System.out.println(System.currentTimeMillis()+"存进："+money);

}

//取钱

public  synchronized void subMoney(int money){

if(count-money  0){

System.out.println("余额不足");

return;

}

count -=money;

System.out.println(+System.currentTimeMillis()+"取出："+money);

}

//查询

public void lookMoney(){

System.out.println("账户余额："+count);

}

}

再看看运行结果：

余额不足

账户余额：0

余额不足

账户余额：0

1441790837380存进：100

账户余额：100

1441790838380取出：100

账户余额：0

1441790838380存进：100

账户余额：100

1441790839381取出：100

账户余额：0

瞬间感觉可以理解了吧。

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

（2）同步代码块

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

Bank.java代码如下：

package threadTest;

/**

* @author ww

*

*/

public class Bank {

private int count =0;//账户余额

//存钱

public   void addMoney(int money){

synchronized (this) {

count +=money;

}

System.out.println(System.currentTimeMillis()+"存进："+money);

}

//取钱

public   void subMoney(int money){

synchronized (this) {

if(count-money  0){

System.out.println("余额不足");

return;

}

count -=money;

}

System.out.println(+System.currentTimeMillis()+"取出："+money);

}

//查询

public void lookMoney(){

System.out.println("账户余额："+count);

}

}

运行结果如下：

余额不足  

账户余额：0  

1441791806699存进：100  

账户余额：100  

1441791806700取出：100  

账户余额：0  

1441791807699存进：100  

账户余额：100

效果和方法一差不多。

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

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

a.volatile关键字为域变量的访问提供了一种免锁机制

b.使用volatile修饰域相当于告诉虚拟机该域可能会被其他线程更新

c.因此每次使用该域就要重新计算，而不是使用寄存器中的值

d.volatile不会提供任何原子操作，它也不能用来修饰final类型的变量

Bank.java代码如下：

package threadTest;

/**

* @author ww

*

*/

public class Bank {

private volatile int count = 0;// 账户余额

// 存钱

public void addMoney(int money) {

count += money;

System.out.println(System.currentTimeMillis() + "存进：" + money);

}

// 取钱

public void subMoney(int money) {

if (count - money  0) {

System.out.println("余额不足");

return;

}

count -= money;

System.out.println(+System.currentTimeMillis() + "取出：" + money);

}

// 查询

public void lookMoney() {

System.out.println("账户余额：" + count);

}

}

运行效果怎样呢？

余额不足

账户余额：0

余额不足

账户余额：100

1441792010959存进：100

账户余额：100

1441792011960取出：100

账户余额：0

1441792011961存进：100

账户余额：100

是不是又看不懂了，又乱了。这是为什么呢？就是因为volatile不能保证原子操作导致的，因此volatile不能代替synchronized。此外volatile会组织编译器对代码优化，因此能不使用它就不适用它吧。它的原理是每次要线程要访问volatile修饰的变量时都是从内存中读取，而不是存缓存当中读取，因此每个线程访问到的变量值都是一样的。这样就保证了同步。

（4）使用重入锁实现线程同步

在JavaSE5.0中新增了一个java.util.concurrent包来支持同步。ReentrantLock类是可重入、互斥、实现了Lock接口的锁， 它与使用synchronized方法和快具有相同的基本行为和语义，并且扩展了其能力。

ReenreantLock类的常用方法有：

ReentrantLock() : 创建一个ReentrantLock实例

lock() : 获得锁

unlock() : 释放锁

注：ReentrantLock()还有一个可以创建公平锁的构造方法，但由于能大幅度降低程序运行效率，不推荐使用 

Bank.java代码修改如下：

package threadTest;

import java.util.concurrent.locks.Lock;

import java.util.concurrent.locks.ReentrantLock;

/**

* @author ww

*

*/

public class Bank {

private  int count = 0;// 账户余额

//需要声明这个锁

private Lock lock = new ReentrantLock();

// 存钱

public void addMoney(int money) {

lock.lock();//上锁

try{

count += money;

System.out.println(System.currentTimeMillis() + "存进：" + money);

}finally{

lock.unlock();//解锁

}

}

// 取钱

public void subMoney(int money) {

lock.lock();

try{

if (count - money  0) {

System.out.println("余额不足");

return;

}

count -= money;

System.out.println(+System.currentTimeMillis() + "取出：" + money);

}finally{

lock.unlock();

}

}

// 查询

public void lookMoney() {

System.out.println("账户余额：" + count);

}

}

运行效果怎么样呢？

余额不足

账户余额：0

余额不足

账户余额：0

1441792891934存进：100

账户余额：100

1441792892935存进：100

账户余额：200

1441792892954取出：100

账户余额：100

效果和前两种方法差不多。

如果synchronized关键字能满足用户的需求，就用synchronized，因为它能简化代码 。如果需要更高级的功能，就用ReentrantLock类，此时要注意及时释放锁，否则会出现死锁，通常在finally代码释放锁 

（5）使用局部变量实现线程同步

Bank.java代码如下：

package threadTest;

/**

* @author ww

*

*/

public class Bank {

private static ThreadLocalInteger count = new ThreadLocalInteger(){

@Override

protected Integer initialValue() {

// TODO Auto-generated method stub

return 0;

}

};

// 存钱

public void addMoney(int money) {

count.set(count.get()+money);

System.out.println(System.currentTimeMillis() + "存进：" + money);

}

// 取钱

public void subMoney(int money) {

if (count.get() - money  0) {

System.out.println("余额不足");

return;

}

count.set(count.get()- money);

System.out.println(+System.currentTimeMillis() + "取出：" + money);

}

// 查询

public void lookMoney() {

System.out.println("账户余额：" + count.get());

}

}

运行效果：

余额不足

账户余额：0

余额不足

账户余额：0

1441794247939存进：100

账户余额：100

余额不足

1441794248940存进：100

账户余额：0

账户余额：200

余额不足

账户余额：0

1441794249941存进：100

账户余额：300

看了运行效果，一开始一头雾水，怎么只让存，不让取啊？看看ThreadLocal的原理：

如果使用ThreadLocal管理变量，则每一个使用该变量的线程都获得该变量的副本，副本之间相互独立，这样每一个线程都可以随意修改自己的变量副本，而不会对其他线程产生影响。现在明白了吧，原来每个线程运行的都是一个副本，也就是说存钱和取钱是两个账户，知识名字相同而已。所以就会发生上面的效果。

ThreadLocal与同步机制 

a.ThreadLocal与同步机制都是为了解决多线程中相同变量的访问冲突问题

b.前者采用以"空间换时间"的方法，后者采用以"时间换空间"的方式

分享文章：java中线程同步的代码 java线程同步方法有哪些
网站链接：http://myzitong.com/article/ddghjhh.html