多线程编程在Java中是一个重要但复杂的主题。使用多线程可以有效地提高应用程序的性能，但同时也可能导致数据不一致、死锁和其他一些难以预料的错误。在这篇文章中，我们将介绍一些常见的多线程编程陷阱及其解决方案。
1. 竞态条件与解决方案
陷阱: 竞态条件是当多个线程尝试同时访问和修改共享数据时，导致程序的输出取决于线程执行的确切时序。
代码示例：
public class Counter {
private int count = 0;
public void increment() {
count++;
}
public int getCount() {
return count;
}
}
public class Main {
public static void main(String[] args) throws InterruptedException {
Counter counter = new Counter();
Thread t1 = new Thread(() -> {
for (int i = 0; i < 1000; i++) {
counter.increment();
}
});
Thread t2 = new Thread(() -> {
for (int i = 0; i < 1000; i++) {
counter.increment();
}
});
t1.start();
t2.start();
t1.join();
t2.join();
System.out.println("Counter: " + counter.getCount());
}
}
以上代码中，我们期望的输出是2000，但是由于竞态条件的存在，我们可能会得到小于2000的结果。
解决方案：使用synchronized关键字来同步代码块或方法。
public class Counter {
private int count = 0;
public synchronized void increment() {
count++;
}
public int getCount() {
return count;
}
}
通过同步，我们确保了每次只有一个线程可以访问increment()方法。
2. 死锁与解决方案
陷阱: 死锁是指两个或多个线程无限期地等待彼此释放资源，导致线程无法继续执行。
代码示例：
public class Resource {
}
public class Main {
public static void main(String[] args) {
final Resource resource1 = new Resource();
final Resource resource2 = new Resource();
Thread t1 = new Thread(() -> {
synchronized (resource1) {
System.out.println("Thread 1: locked resource 1");
try {
Thread.sleep(100);
} catch (InterruptedException e) {
e.printStackTrace();
}
synchronized (resource2) {
System.out.println("Thread 1: locked resource 2");
}
}
});
Thread t2 = new Thread(() -> {
synchronized (resource2) {
System.out.println("Thread 2: locked resource 2");
try {
Thread.sleep(100);
} catch (InterruptedException e) {
e.printStackTrace();
}
synchronized (resource1) {
System.out.println("Thread 2: locked resource 1");
}
}
});
t1.start();
t2.start();
}
}
在上面的代码中，两个线程试图按相反的顺序获取两个资源的锁，这会导致死锁。
解决方案: 总是以固定的顺序获取资源的锁。
public class Main {
public static void main(String[] args) {
final Resource resource1 = new Resource();
final Resource resource2 = new Resource();
Thread t1 = new Thread(() -> {
synchronized (resource1) {
System.out.println("Thread 1: locked resource 1");
try {
Thread.sleep(100);
} catch (InterruptedException e) {
e.printStackTrace();
}
synchronized (resource2) {
System.out.println("Thread 1: locked resource 2");
}
}
});
Thread t2 = new Thread(() -> {
synchronized (resource1) {
System.out.println("Thread 2: locked resource 1");
try {
Thread.sleep(100);
} catch (InterruptedException e) {
e.printStackTrace();
}
synchronized (resource2) {
System.out.println("Thread 2: locked resource 2");
}
}
});
t1.start();
t2.start();
}
}
上述解决方案确保了所有线程都是按照相同的顺序尝试获得资源锁，从而避免了死锁。
到此，我们已经介绍了两个常见的多线程编程陷阱及其解决方案。在接下来的部分，我们将继续探讨其他陷阱及其解决策略。
接下来，我们将探讨其他常见的多线程编程陷阱及其解决策略。
3. 线程饥饿与解决方案
陷阱: 线程饥饿是指某些线程无法获得足够的CPU时间来执行其任务。这可能是因为其他高优先级的线程占用了大部分的CPU时间。
代码示例：
public class Main {
public static void main(String[] args) {
Thread highPriorityThread = new Thread(() -> {
while (true) {
System.out.println("High priority thread is running");
}
});
highPriorityThread.setPriority(Thread.MAX_PRIORITY);
Thread lowPriorityThread = new Thread(() -> {
while (true) {
System.out.println("Low priority thread is running");
}
});
lowPriorityThread.setPriority(Thread.MIN_PRIORITY);
highPriorityThread.start();
lowPriorityThread.start();
}
}
在上述代码中，高优先级线程可能会占用大部分CPU时间，导致低优先级线程得不到足够的执行机会。
解决方案: 避免使用不同的线程优先级，或者仅在必要时使用，同时确保所有线程都有足够的时间来执行其任务。
4. 不正确的线程同步与解决方案
陷阱: 线程同步是确保多个线程可以安全地共享数据或资源的一种方法。但是，如果不正确地使用线程同步，可能会导致性能问题或不一致的数据。
代码示例：
public class SharedResource {
private int value;
public synchronized int getValue() {
return value;
}
public synchronized void setValue(int value) {
this.value = value;
}
}
public class Main {
public static void main(String[] args) {
SharedResource resource = new SharedResource();
// Many threads trying to get value
for (int i = 0; i < 10; i++) {
new Thread(() -> {
System.out.println(resource.getValue());
}).start();
}
}
}
在上述代码中，我们为getValue()和setValue()方法都添加了synchronized关键字，但是getValue()方法其实并不需要同步，因为它只是读取数据。
解决方案: 使用java.util.concurrent包中的工具类，如ReentrantReadWriteLock，它允许多个线程同时读取数据，但只允许一个线程写入数据。
import java.util.concurrent.locks.ReentrantReadWriteLock;
public class SharedResource {
private int value;
private final ReentrantReadWriteLock lock = new ReentrantReadWriteLock();
public int getValue() {
lock.readLock().lock();
try {
return value;
} finally {
lock.readLock().unlock();
}
}
public void setValue(int value) {
lock.writeLock().lock();
try {
this.value = value;
} finally {
lock.writeLock().unlock();
}
}
}
使用ReentrantReadWriteLock可以提高性能，因为读操作不会被阻塞，除非有一个线程正在执行写操作。
5. 过度同步与解决方案
陷阱: 过度同步是指不必要地同步代码块或方法，导致性能下降。
代码示例：
public synchronized void doSomething() {
// long running non-critical section
doNonCriticalWork();
// critical section
doCriticalWork();
}
在上面的代码中，整个doSomething()方法都被同步了，尽管只有doCriticalWork()部分真正需要同步。
解决方案: 只同步关键部分的代码。
public void doSomething() {
// long running non-critical section
doNonCriticalWork();
synchronized (this) {
// critical section
doCriticalWork();
}
}
确保只同步真正需要同步的代码部分，可以提高应用程序的性能。
以上，我们继续探讨了多线程编程中的陷阱及其解决方案。在下一部分，我们将继续深入讨论其他相关主题。
继续我们的讨论，我们将深入探讨更多的多线程编程中的陷阱及其解决方案。
6. 可见性问题与解决方案
陷阱: 在Java中，线程之间的数据可见性是不保证的。一个线程对变量的修改可能对其他线程不可见，除非使用适当的同步机制。
代码示例：
public class VisibilityIssue {
private boolean flag = false;
public void setFlagTrue() {
flag = true;
}
public void checkFlag() {
while (!flag) {
// Waiting for flag to be true
}
System.out.println("Flag is now true!");
}
public static void main(String[] args) {
VisibilityIssue issue = new VisibilityIssue();
new Thread(issue::checkFlag).start();
try {
Thread.sleep(1000);
} catch (InterruptedException e) {
e.printStackTrace();
}
issue.setFlagTrue();
}
}
上述代码中，checkFlag方法可能会永远运行，因为flag的修改可能对这个方法不可见。
解决方案: 使用volatile关键字，确保变量的修改对所有线程都可见。
public class VisibilitySolution {
private volatile boolean flag = false;
// ... remaining code is same as before
}
7. 忙等待与解决方案
陷阱: 当线程通过循环不断检查某个条件，而不进行实质性的工作时，称为忙等待。这浪费了CPU资源。
代码示例：与上述可见性问题中的代码相似，checkFlag方法中的循环就是忙等待的一个例子。
解决方案: 使用Java的并发工具，例如java.util.concurrent包中的Condition、Semaphore或CountDownLatch。
以下是使用CountDownLatch的例子：
import java.util.concurrent.CountDownLatch;
public class BusyWaitSolution {
private final CountDownLatch latch = new CountDownLatch(1);
public void release() {
latch.countDown();
}
public void waitForRelease() throws InterruptedException {
latch.await();
System.out.println("Latch has been released!");
}
public static void main(String[] args) {
BusyWaitSolution solution = new BusyWaitSolution();
new Thread(() -> {
try {
solution.waitForRelease();
} catch (InterruptedException e) {
e.printStackTrace();
}
}).start();
try {
Thread.sleep(1000);
} catch (InterruptedException e) {
e.printStackTrace();
}
solution.release();
}
}
8. 使用错误的同步对象
陷阱: 使用不正确的对象来同步可能导致意外的行为。
代码示例：
public class SynchronizationIssue {
private final Integer lock = Integer.valueOf(0);
public void synchronizedMethod() {
synchronized (lock) {
// critical section
}
}
}
在上述代码中，使用Integer对象作为锁可能不是一个好主意，因为Integer对象是不可变的，并且可以被缓存。
解决方案: 使用专门的锁对象，或者直接同步方法/代码块。
public class SynchronizationSolution {
private final Object lock = new Object();
public void synchronizedMethod() {
synchronized (lock) {
// critical section
}
}
}
以上，我们讨论了Java多线程编程中的各种常见陷阱以及它们的解决方案。多线程编程是一个复杂的主题，需要深入学习和大量的实践经验。希望本文能为你在Java多线程编程的旅程中提供有价值的指导。
扫一扫
419
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
