java多线程 synchronized volatile Atomic LOCK的使用

java中可以使用 synchronized volatile Atomic LOCK进行多线程编程来实现线程安全。现对这几种方式进行演示与总结。

其中：

1. 单纯使用volatile是没有办法保证线程安全的

2. 使用synchronized和 lock要注意使用方法，要在主进程中创建lock对象的实例或定义synchronized方法

3. 使用Atomic 原子类也是可以保证线程安全的。

/**

* @Package
* @Description
* @author chenj
* @date 2015-9-14 下午11:09:40
* @version V1.0
*/

import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.atomic.AtomicInteger;
import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;

/**
*
* @author chenj| 2015-01-01
*
*/
public class TestMultiThread{
Object _object = new Object();

static int i=0;

static Integer si = 0;

static volatile Integer vi = 0;

static AtomicInteger autoInteger = new AtomicInteger();

static int synClassInt = 0;

static int lockInt = 0;

static int staticClassInt = 0;

static Lock lock = new ReentrantLock();

static Object _obj = new Object();

public void testVolatileInteger(Thread _thread1,Thread _thread2) throws Exception{
ExecutorService pool = Executors.newCachedThreadPool();
//创建实现了Runnable接口对象，Thread对象当然也实现了Runnable接口
Thread t1 = _thread1;
Thread t2 = _thread2;
//将线程放入池中进行执行
pool.execute(t1);
pool.execute(t2);
//关闭线程池
pool.shutdown();
while(true){
if(pool.isTerminated()){
if(staticClassInt!=0){
System.out.println("所有的子线程都结束了！");
System.out.println("i>>>>>"+i);
System.out.println("vi>>>>>"+vi);
System.out.println("si>>>>>"+si);
System.out.println("autoInteger>>>>>"+autoInteger);
System.out.println("synClassInt>>>>>"+synClassInt);
System.out.println("lockInt>>>>>"+lockInt);
System.out.println("staticClassInt>>>>>"+staticClassInt);
}
break;
}
}
}

public synchronized static void testSychronizedMethod() {
i++;
}

static class testSychronizedMethodClass extends Thread{
@Override
public void run() {
for(int k=0;k<200000;k++){
testValue();
}
}
public static void testValue() {

staticClassInt++ ;
}
}

public static void main(String[] args) throws Exception{
TestMultiThread testMultiThread = new TestMultiThread();

testMultiThread.testVolatileInteger(new ThreadSychronizedMethead(),new ThreadSychronizedMethead());
Thread.sleep(100);

testMultiThread.testVolatileInteger(new ThreadStaticInteger(),new ThreadStaticInteger());
Thread.sleep(100);

testMultiThread.testVolatileInteger(new ThreadStaticVolatileInteger(),new ThreadStaticVolatileInteger());
Thread.sleep(100);

testMultiThread.testVolatileInteger(new ThreadAtomicInteger(),new ThreadAtomicInteger());
Thread.sleep(100);

testMultiThread.testVolatileInteger(new ThreadSychronizedObjMethead(),new ThreadSychronizedObjMethead());
Thread.sleep(100);

testMultiThread.testVolatileInteger(new ThreadLock(),new ThreadLock());
Thread.sleep(100);

testMultiThread.testVolatileInteger(new TestMultiThread.testSychronizedMethodClass(),new TestMultiThread.testSychronizedMethodClass());
Thread.sleep(100);
}
}

class ThreadStaticVolatileInteger extends Thread {
@Override
public void run() {
for(int k=0;k<200000;k++){
TestMultiThread.vi++;
}
}
}

class ThreadAtomicInteger extends Thread {
@Override
public void run() {
for(int k=0;k<200000;k++){
TestMultiThread.autoInteger.incrementAndGet();
}
}
}

class ThreadStaticInteger extends Thread {
@Override
public void run() {
for(int k=0;k<200000;k++){
TestMultiThread.si++;
}
}
}

class ThreadSychronizedMethead extends Thread {
@Override
public void run() {
for(int k=0;k<200000;k++){
TestMultiThread.testSychronizedMethod();
}
}

public synchronized void test() {
TestMultiThread.i++;
}
}

class ThreadSychronizedObjMethead extends Thread {
@Override
public void run() {
for(int k=0;k<200000;k++){
synchronized(TestMultiThread._obj){
TestMultiThread.synClassInt++;
}
}
}
}

class ThreadLock extends Thread {

@Override
public void run() {
for(int k=0;k<200000;k++){
lockObj();
}
}

public void lockObj(){
TestMultiThread.lock.lock();
try{
TestMultiThread.lockInt ++;
}finally{
TestMultiThread.lock.unlock();
}
}
}

程序运行结果：

所有的子线程都结束了！

i>>>>>400000

vi>>>>>257432

si>>>>>222170

autoInteger>>>>>400000

synClassInt>>>>>400000

lockInt>>>>>400000

staticClassInt>>>>>266997