Java同步问题_java同步问题演示及简单解决方案

本文适合读者群为对java多线程有一定了解的人(知道Thread和Runnable)。

线程同步是一个经常被人谈及的话题。这篇博客讲的就是java的线程同步问题。

首先，我们来看下面的一个类。

package com.cici.threads;

public class Plus implements Runnable{

private long num = 0;

public void run(){

a();

}

private void a() {

for(int i=0;i<100;i++){

num++;

if(num%1000==0)

System.out.println("num:"+num);

}

}

}

这是一个很简单的实现Runnable接口的类，它单线程运行的结果就是将其属性num从0加到一百。if语句的意思是，如果num成为1000的整数倍，则输出num的值。

package com.cici.test;

public class Test {

/**

* @param args

*/

public static void main(String[] args) {

Test test = new Test();

// 根据类名得到实现Runnable接口的对象

Runnable rb = test.getRunnable("Plus5");

//并发执行

test.runInGroup(rb,4000);

}

/**

* 将同一个Runnable对象产生多个线程，并发执行

* @param rb Runnable对象

* @param num 线程的数量

*/

public void runInGroup(Runnable rb,int num){

ThreadGroup thg = new ThreadGroup();

for(int i=0;i

Thread th = new Thread(rb);

thg.add(th);

}

thg.startGroup();

}

/**

* 根据类的名字获得线程实例

* @param className

* @return 线程对象，如发生异常，则返回null

*/

public Runnable getRunnable(String className){

className = "com.cici.threads."+className;

try {

Runnable rb = (Runnable)Class.forName(className).newInstance();

return rb;

} catch (InstantiationException e) {

// TODO Auto-generated catch block

e.printStackTrace();

} catch (IllegalAccessException e) {

// TODO Auto-generated catch block

e.printStackTrace();

} catch (ClassNotFoundException e) {

// TODO Auto-generated catch block

e.printStackTrace();

}

return null;

}

}

这一段代码的意思为实例化一个Plus对象，并将其在4000个线程中运行。按照我们惯性的思维，num的值应该变成400000，所以控制台最后输出的值应该是。。。399000，400000。但是实践才能出真知，有心的读者可以试一试最后的结果是什么。我机器上的结果是num的值最后没有到400000，至于你信不信，反正我是信了。这种问题在java里面可以归结为线程同步问题。在我的电脑上，本实验中在10~100这个数量级上还没有发生过这种问题，当线程数到1000的时候，这个问题就比较明显了。

查阅资料，我们知道，当多个线程对互斥资源同时进行操作时，就有可能发生同步问题。在java语言中，我们可以有许多办法解决这个问题，以下列举几个。

1.synchronized方法

package com.cici.threads;

public class Plus1 implements Runnable{

private long num = 0;

public void run(){

a();

}

private synchronized void a() {

for(int i=0;i<100;i++){

num++;

if(num%1000==0)

System.out.println("num:"+num);

}

}

}

这是一种很常见的解决方案，被synchronized修饰的方法同时只能有一个线程进入，其他线程都会等进入的线程离开了才会尝试进入。

2.synchronized代码块

package com.cici.threads;

public class Plus2 implements Runnable{

private Integer num = 0;

private byte[] lock = new byte[0];

public void run(){

a();

}

private void a() {

for(int i=0;i<100;i++){

synchronized(lock){

num++;

if(num%1000==0)

System.out.println("num:"+num);

}

}

}

}

synchronized同步块则是更具有普遍适用性的方案，synchronized同步块需要给它一个object来实现互斥synchronized方法其实就相当于synchronized(this),在某些情况下方法中某些代码不能出现在同步块中，所以只能将synchronized同步块拆分得更细

3.java.util.concurrent.lock包中的类

package com.cici.threads;

import java.util.concurrent.locks.Lock;

import java.util.concurrent.locks.ReentrantLock;

public class Plus3 implements Runnable{

private long num = 0;

private Lock lock = new ReentrantLock();

public void run(){

a();

}

private void a() {

for(int i=0;i<100;i++){

lock.lock();

num++;

if(num%1000==0)

System.out.println("num:"+num);

lock.unlock();

}

}

}

如果你理解了synchronized代码块，那么恭喜，上面一段的代码你也懂了。还是加锁的意思，只不过将原生语法改为了API的调用，某些情况下，这样做性能更好，另外，API能提供synchronized办不到的事，比如保证锁的公平性

4.java.util.concurrent.atomic包中的类

package com.cici.threads;

import java.util.concurrent.atomic.AtomicLong;

public class Plus4 implements Runnable{

private AtomicLong num = new AtomicLong(0);

public void run(){

a();

}

private void a() {

for(int i=0;i<100;i++){

num.addAndGet(1);

if((num.get())%1000==0)

System.out.println("num:"+num);

}

}

}

对一个atomicLong类型的对象调用addAndGet方法逻辑上和对一个long类型的值进行++操作是完全一样的。但是addAndGet方法是原子的，由硬件保证，所以同步问题就不会出现了