实战：Java中的并发控制——线程同步

原创布满荆棘的人生 2024-11-02 01:48 29阅读 0赞

在Java中，线程同步是并发控制的一个重要方面，它确保了多个线程在访问共享资源时的一致性和线程安全。以下是一些实现线程同步的方法：

1. **synchronized关键字**：
-可以修饰方法或代码块。
- 当一个线程访问某个对象的synchronized方法或代码块时，它会获取该对象的锁，其他线程则无法访问该对象的任何synchronized方法或代码块，直到锁被释放。

```java public class Counter {
 private int count =0;

public synchronized void increment() {
 count++;
 }

public synchronized int getCount() {
 return count;
 }
 }
 ```2. **Lock接口**：
- `java.util.concurrent.locks.Lock`提供了比synchronized更灵活的锁定机制。
-它允许尝试非阻塞地获取锁、尝试超时获取锁以及中断锁的获取。

```javaimport java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;

public class Counter {
 private final Lock lock = new ReentrantLock();
 private int count =0;

public void increment() {
lock.lock();
 try {
 count++;
} finally {
lock.unlock();
 }
 }

public int getCount() {
lock.lock();
 try {
 return count;
} finally {
lock.unlock();
 }
 }
 }
 ```3. **volatile关键字**：
-确保变量的修改对所有线程立即可见。
-但是，它不保证复合操作的原子性。

```java public class Flag {
 private volatile boolean flag = false;

public void setFlag() {
 flag = true;
 }

public boolean isFlagSet() {
 return flag;
 }
 }
 ```4. **原子类**：
- `java.util.concurrent.atomic`包提供了一组原子类，如`AtomicInteger`、`AtomicLong`等，它们利用CAS（Compare-And-Swap）操作来保证操作的原子性。

```javaimport java.util.concurrent.atomic.AtomicInteger;

public class Counter {
 private AtomicInteger count = new AtomicInteger(0);

public void increment() {
 count.incrementAndGet();
 }

public int getCount() {
 return count.get();
 }
 }
 ```5. **线程局部变量**：
- 使用`ThreadLocal`类可以为每个线程创建变量的独立副本，从而避免共享。

```javaimport java.util.concurrent.ThreadLocal;

public class ThreadLocalExample {
 private static ThreadLocal<Integer> threadLocalValue = new ThreadLocal<>();

public void set(int value) {
 threadLocalValue.set(value);
 }

public int get() {
 return threadLocalValue.get();
 }
 }
 ```6. **不可变对象**：
- 不可变对象的属性在构造后不能被改变，因此它们是线程安全的。

```java public final class ImmutableObject {
 private final int value;

public ImmutableObject(int value) {
 this.value = value;
 }

public int getValue() {
 return value;
 }
 }
 ```使用这些技术可以有效地控制并发，确保线程安全。在实际应用中，应根据具体需求选择合适的同步机制。