[英]Java synchronization: Synchronization method and synchronization block
我有一个mulitThread Java应用程序。 在一种方法中,需要同步ArrayList。 由于arrayList不是线程安全的,所以我必须使用同步化。 问题是类型为ArrayList的对象不是该对象的成员变量。 该方法的原型如下:
public void simultaneousAccess(ArrayListWrapper aListWrapper){
ArrayList list = aListWrapper.getList();
//...Codes manipulate the list
}
由于多线程,我应该使用
一种)
public void synchronized simultaneousAccess(ArrayListWrapper aListWrapper){
ArrayList list = aListWrapper.getList();
//...Codes manipulate the list
}
要么
B)
public void simultaneousAccess(ArrayListWrapper aListWrapper){
ArrayList list = aListWrapper.getList();
Synchronized(list){
//...Codes manipulate the list
}
}
从性能测试来看,两者均无效。 但是我不知道为什么?
以下是完整的源代码:
package com.juhani.prototype.sync;
import java.util.ArrayList;
public class ArrayListWrapper {
public ArrayList<Integer> aList = new ArrayList<Integer>();
public ArrayListWrapper(){
Integer one = new Integer(1);
Integer two = new Integer(2);
Integer three = new Integer(3);
aList.add(one);
aList.add(two);
aList.add(three);
}
}
package com.juhani.prototype.sync;
import java.util.ArrayList;
public class TestClass {
public int count_test=0;
public synchronized void test(ArrayListWrapper listWrapper){
ArrayList<Integer> list = listWrapper.aList;
int temp = list.get(1)+1;
list.set(1,temp);
}
public void testBlock(ArrayListWrapper listWrapper){
ArrayList<Integer> list = listWrapper.aList;
synchronized(list){
int temp = list.get(1)+1;
list.set(1,temp);
}
}
}
package com.juhani.prototype.sync;
public class WorkerSyncObj extends Thread {
ArrayListWrapper listWrapper = null;
TestClass tc = null;
int number;
public WorkerSyncObj(int aNumber){
number = aNumber;
}
public void setListWrapper(ArrayListWrapper aListWrapper){
listWrapper = aListWrapper;
}
public void setTestClass(TestClass aTc){
tc = aTc;
}
public void run(){
int i = 1000;
for(int j=0;j<i;j++){
tc.testBlock(listWrapper);
System.out.println("Thread "+number+" is runing at loop "+j+" . index 1 value is:"+listWrapper.aList.get(1));
}
}
}
package com.juhani.prototype.sync.main;
import com.juhani.prototype.sync.ArrayListWrapper;
import com.juhani.prototype.sync.TestClass;
import com.juhani.prototype.sync.WorkerSyncObj;
public class TestMain {
public static void main(String[] args){
ArrayListWrapper list = new ArrayListWrapper();
TestClass tc = new TestClass();
WorkerSyncObj work1 = new WorkerSyncObj(1);
work1.setListWrapper(list);
work1.setTestClass(tc);
WorkerSyncObj work2 = new WorkerSyncObj(2);
work2.setListWrapper(list);
work2.setTestClass(tc);
WorkerSyncObj work3 = new WorkerSyncObj(3);
work3.setListWrapper(list);
work3.setTestClass(tc);
work1.start();
work2.start();
work3.start();
}
}
在第一种情况下,您锁定this
对象,而在第二种情况下,锁定list
对象。 如果您从不同的对象调用方法,但列表相同,则可能会出现问题。 这可能是第一种情况例外的原因。
或者,您可以尝试一些内置的并发类型,例如Collections.synchronizedList
或CopyOnWriteArrayList
。
在Java中,每个对象实例都有一个内在锁(以及对应的类本身)。 同步键盘实际上是使用固有锁进行互斥访问,即
syncrhonized method(...) {...}
等于
method(...) {
this.intrinsicLock.lock();
...;
this.intrinsicLock.unlock() }
和
synchronized( obj_ref ) { ... }
等于
obj_ref.intrinsicLock.lock();
{...}
obj_ref.instrinsicLock.unlock();
因此,同步化方法不适用于列表(参数)的保护。 如果使用ynchronized(list),则有两个问题:1.独占访问的粒度似乎有点粗糙。2.在整个程序中的任何地方,每个列表访问也都需要使用“ synchronized(list)”。 这是一个协议(专用访问)。
这就是Java库提供大量并发数据结构的原因。
声明:本站的技术帖子网页,遵循CC BY-SA 4.0协议,如果您需要转载,请注明本站网址或者原文地址。任何问题请咨询:yoyou2525@163.com.