synchronized的使用

在编写一个类时，如果该类中的代码可能运行于多线程环境下，那么就要考虑同步的问题。在Java中内置了语言级的同步原语－－synchronized，这也大大简化了Java中多线程同步的使用。

直接上代码

package com.crm.learn.thread;

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

public class TestThread {

	public static CountDownLatch count = new CountDownLatch(2);

	public static Object o = new Object();
	public static Long numx = new Long(0l);

	public static void main(String[] args) {
		Lock mainLock = new ReentrantLock();
		try {
			VThread v1 = new VThread(1000000, mainLock);
			VThread v2 = new VThread(2000000, mainLock);
			
			v1.start();
			v2.start();
			count.await();
			System.out.println(numx);
		} catch (Exception e) {
			e.printStackTrace();
		}
	}

}

 

线程类

package com.crm.learn.thread;

import java.util.concurrent.locks.Lock;

public class VThread extends Thread {

	private long addNum = 0;
	private Lock mainLock;

	public VThread(long addNum, Lock mainLock) {
		this.addNum = addNum;
		this.mainLock = mainLock;
	}

	public void run() {
		try {
			for (int i = 0; i < addNum; i++) {
				try {
					//如果锁定numx,数量 != 3000000
//					synchronized (TestThread.numx) {
//						TestThread.numx++;
//					}
					
					//如果锁定o,数量 =3000000
//					synchronized (TestThread.o) {
//						TestThread.numx++;
//					}
					
					//如果锁定TestThread.class,数量 =3000000
//					synchronized (TestThread.class) {
//						TestThread.numx++;
//					}
					
					//使用锁对象,数量 =3000000
//					mainLock.lock();
//					TestThread.numx++;
//					mainLock.unlock();
					
				} catch (Exception e) {
					e.printStackTrace();
				}
			}
		} catch (Exception e) {
			e.printStackTrace();
		} finally {
			TestThread.count.countDown();
		}
	}
}

 

 

为啥

synchronized (TestThread.numx) {

TestThread.numx++;

 

}

这个值不为3000000

评论

4 楼 toknowme 2015-10-29  

lisaiori 写道

// synchronized (TestThread.numx) { 
//      TestThread.numx++; 
// } 
第一次循环的时候，TestThread.numx 是静态成员变量，多个线程之间访问的是同一把锁
然而每次++运算之后，会 new 一个新的Long对象出来，这样多个线程之间，锁定的对象就不是同一个了。所以，结果不对。

还是昊子大神给力！  

3 楼 lisaiori 2015-10-27  

// synchronized (TestThread.numx) { 
//      TestThread.numx++; 
// } 
第一次循环的时候，TestThread.numx 是静态成员变量，多个线程之间访问的是同一把锁
然而每次++运算之后，会 new 一个新的Long对象出来，这样多个线程之间，锁定的对象就不是同一个了。所以，结果不对。

2 楼 toknowme 2015-09-08  

老兄！你这是两个不同的线程，不同的SynchronizedCode 对象，各跑各的没有问题呀。
synchronized (this)这里的this要是同一个对象才行，需要将对象从类的外面传进去，你在这里写死，它永远不可能时同一个对象。

看来还是这个老兄厉害

package com.crm.learn.thread;

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

public class TestThread {

	public static CountDownLatch count = new CountDownLatch(2);

	public static Long o = new Long(01);
	public static Long numx = new Long(0l);

	public static void main(String[] args) {
		Lock mainLock = new ReentrantLock();
		try {
			VThread v1 = new VThread(1000000, mainLock, numx);
			VThread v2 = new VThread(2000000, mainLock, numx);

			v1.start();
			v2.start();
			count.await();
			System.out.println(numx);
		} catch (Exception e) {
			e.printStackTrace();
		}
	}

}

package com.crm.learn.thread;

import java.util.concurrent.locks.Lock;

public class VThread extends Thread {

	private long addNum = 0;
	private Lock mainLock;
	private Object self;

	public VThread(long addNum, Lock mainLock, Object self) {
		this.addNum = addNum;
		this.mainLock = mainLock;
		this.self = self;
	}

	public void run() {
		try {
			for (int i = 0; i < addNum; i++) {
				try {
					// 如果锁定numx,数量 != 3000000
					// synchronized (TestThread.numx) {
					// TestThread.numx++;
					// }

					// 如果锁定o,数量 =3000000
					// synchronized (TestThread.o) {
					// TestThread.numx++;
					// }

					// 如果锁定TestThread.class,数量 =3000000
					// synchronized (TestThread.class) {
					// TestThread.numx++;
					// }

					// 使用锁对象,数量 =3000000
					// mainLock.lock();
					// TestThread.numx++;
					// mainLock.unlock();

					// 锁定自己
					synchronized (self) {
						TestThread.numx++;
					}

				} catch (Exception e) {
					e.printStackTrace();
				}
			}
		} catch (Exception e) {
			e.printStackTrace();
		} finally {
			TestThread.count.countDown();
		}
	}
}

1 楼 toknowme 2015-09-08  

自己补一刀：

synchronized必须在同一个实例中使用。

两次new之后，生成两个实例，各自的synchronized不会对其它实例的thread起作用。

这个应该怎么理解？