java中线程同步的代码 java线程同步方法有哪些
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