[英]Is this Java thread locking concept bad?
我将尝试通过一个示例简要解释我提出的线程锁定概念。 考虑以下示例程序。
public class Main {
public static void main(String[] args) {
Data data = new Data();
while (true) {
doStuff();
doStuff();
for (int i = 0; i < 256; i++) {
System.out.println("Data " + i + ": " + data.get(i));
}
doStuff();
doStuff();
for (int i = 0; i < 256; i++) {
data.set(i, (byte) (data.get(i) + 1));
}
doStuff();
doStuff();
}
}
public static void doStuff() {
try {
Thread.sleep(10);
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
public class Data {
private final byte[] data = new byte[256];
public byte get(int i) {
return data[i];
}
public void set(int i, byte data) {
this.data[i] = data;
}
}
只有主线程才能修改data
,这一点很重要。 现在,我要使打印data
异步的循环。
public static void main(String[] args) {
ExecutorService executorService = Executors.newSingleThreadExecutor();
Data data = new Data();
while (true) {
doStuff();
doStuff();
executorService.submit(new Runnable() {
@Override
public void run() {
for (int i = 0; i < 256; i++) {
System.out.println("Data " + i + ": " + data.get(i));
}
}
});
doStuff();
doStuff();
for (int i = 0; i < 256; i++) {
data.set(i, (byte) (data.get(i) + 1));
}
doStuff();
doStuff();
}
}
在将任务提交给executorService
,主线程现在可以按需继续工作。 问题在于,主线程可能会到达其在打印之前修改data
的位置,但是在提交data
时应打印data
的状态。
我知道在这种情况下,我可以在提交打印之前创建data
的副本,但这实际上不是我想要的。 请记住,这只是一个示例,在实际代码中,复制可能是一项昂贵的操作。
这是我针对此问题提出的解决方案。
public static void main(String[] args) {
ExecutorService executorService = Executors.newSingleThreadExecutor();
Data data = new Data();
Lock lock = new Lock(); // <---------------
while (true) {
doStuff();
doStuff();
lock.lock(); // <---------------
executorService.submit(new Runnable() {
@Override
public void run() {
for (int i = 0; i < 256; i++) {
System.out.println("Data " + i + ": " + data.get(i));
}
lock.unlock(); // <---------------
}
});
doStuff();
doStuff();
lock.waitUntilUnlock(); // <---------------
for (int i = 0; i < 256; i++) {
data.set(i, (byte) (data.get(i) + 1));
}
doStuff();
doStuff();
}
}
public class Lock {
private final AtomicInteger lockCount = new AtomicInteger();
public void lock() {
lockCount.incrementAndGet();
}
public synchronized void unlock() {
lockCount.decrementAndGet();
notifyAll();
}
public synchronized void waitUntilUnlock() {
while (lockCount.get() > 0) {
try {
wait();
} catch (InterruptedException e) {
}
}
}
}
现在,主线程可以在提交data
后继续处理其他内容。 至少它可以直到修改data
为止。
问题:这是好设计还是坏设计? 还是针对此问题有更好的(已经存在的)实现?
请注意,在这种情况下, ReentrantLock
不起作用。 我必须在提交主线程之前锁定并释放执行者线程上的锁定。
Java具有更高级别的同步抽象。 通常,您应该避免使用wait()和notifyAll(),它们太低级且太复杂,无法正确使用和读取。
在这种情况下,您可以只在两个线程之间使用一个共享的阻塞队列(一个同步队列看起来适合我):
ExecutorService executorService = Executors.newSingleThreadExecutor();
Data data = new Data();
SynchronousQueue queue = new SynchronousQueue();
while (true) {
doStuff();
doStuff();
executorService.submit(new Runnable() {
@Override
public void run() {
for (int i = 0; i < 256; i++) {
System.out.println("Data " + i + ": " + data.get(i));
}
queue.put(data);
}
});
doStuff();
doStuff();
data = queue.take();
for (int i = 0; i < 256; i++) {
data.set(i, (byte) (data.get(i) + 1));
}
doStuff();
doStuff();
}
您希望此Data事物是异步构建的,并且主线程希望能够进行到特定点,然后需要获取完成的对象。 这就是期货的用途,它为您提供了可能尚未完成的计算的参考。
将异步部分重写为Callable,以便其返回数据。
Callable<Integer> task = () -> {
Data data = new Data();
for (int i = 0; i < 256; i++) {
System.out.println("Data " + i + ": " + data.get(i));
}
return data;
};
ExecutorService executor = Executors.newFixedThreadPool(1);
Future<Data> future = executor.submit(task);
doStuff();
// ... main thread goes about its business
// when you get to a point where you need data,
// you can block here until the computation is done
Data data = future.get();
这样,Future可以确保确保Data对象在线程之间可见。
我找到了解决该问题的另一种方法,该方法也从@JB Nizet的答案中回答了我的评论。 ExecutorService#submit(Runnable)
返回Future<?>
,可用于等待任务准备就绪。 如果应该进行多个提交,则可以只创建一个Queue<Future<?>> queue
,始终将ExecutorService#submit(Runnable)
返回的Future<?>
提供给该queue
并在该位置主线程仅等待#poll().get()
整个queue
。
编辑:我也在这里找到了一个相关的答案: https : //stackoverflow.com/a/20496115/3882565
基本同步似乎已经足够涵盖了这一点: doStuff
希望能够唯一地访问数据,大概是这样,以便它可以安全地整体修改数据。 同时, doPrint
希望对稳定的数据进行操作。 在这两种情况下,数据是受访问控制的状态单元,并且适当的锁定技术是在要访问的数据实例上进行同步。
public void runningInThread1() {
Data someData = getData(); // Obtain the data which this thread is using
doStuff(someData); // Update the data
// Looping and such omitted.
}
public void runningInThread2() {
Data someData = getData();
doPrint(someData); // Display the data
}
public void doStuff(Data data) {
synchronized ( data ) {
// Do some stuff to the data
}
}
public void doPrint(Data data) {
synchronized ( data ) {
// Display the data
}
}
或者,如果doStuff
和doPrint
被实现为Data
实例方法,则可以通过将doPrint
关键字添加到实例方法来实现synchronized
。
声明:本站的技术帖子网页,遵循CC BY-SA 4.0协议,如果您需要转载,请注明本站网址或者原文地址。任何问题请咨询:yoyou2525@163.com.