【多线程基础】 保证线程安全的总结

🎉🎉🎉点进来你就是我的人了
博主主页：🙈🙈🙈戳一戳,欢迎大佬指点!

欢迎志同道合的朋友一起加油喔🦾🦾🦾

---

目录

一.使用没有共享资源的模型

二.适用共享资源只读，不写的模型

1.不需要写共享资源的模型

2.使用不可变对象

三. 直面线程安全的解决思路

1.互斥锁（synchronized）：

2.volatile关键字：

3.原子操作类

4.隔离（ThreadLocal）：

5.不可变对象：

6.线程安全的集合类：

线程的优点

---

---

一.使用没有共享资源的模型

使用没有共享资源的模型（无共享数据）可以避免多线程环境中的线程安全问题。无共享数据的模型通常是指各个线程独立地处理它们自己的任务，它们不需要访问其他线程的数据，也不需要同步。

这种模型有以下优势：

        1.简化并发编程：由于不存在共享数据，线程间无需同步，这使得编程变得简单，降低了出错的风险。

        2.可伸缩性：由于线程之间不需要竞争共享资源，这种模型可以很好地利用多核处理器的性能，提高系统的吞吐量。

        3.减少锁竞争：无共享数据意味着无需使用锁来保护资源，从而避免了锁竞争带来的性能开销。

        4.易于理解：无共享数据模型不需要复杂的同步逻辑，使得代码更容易理解和维护。

以下是一个简单的无共享数据模型的例子

public class NoSharedResourceExample {
    public static void main(String[] args) {
        Thread threadA = new Thread(() -> {
            for (int i = 0; i < 10; i++) {
                System.out.println("Thread A: " + i);
            }
        });

        Thread threadB = new Thread(() -> {
            for (int i = 0; i < 10; i++) {
                System.out.println("Thread B: " + i);
            }
        });

        threadA.start();
        threadB.start();
    }
}

在这个例子中，线程A和线程B分别执行它们自己的任务，它们之间没有共享任何数据。由于没有共享资源，这个例子不需要使用锁或其他同步机制来保证线程安全。

需要注意的是，无共享数据模型并不适用于所有场景。在某些情况下，线程之间需要共享数据或者进行协作，这时就需要使用其他方法来确保线程安全。无共享数据模型更适合那些可以自然地将任务拆分成互不依赖的子任务的场景。

---

二.适用共享资源只读，不写的模型

1.不需要写共享资源的模型

在这种模型中，线程可以共享数据，但只能进行读操作，而不能进行写操作。由于不存在数据修改，因此不需要同步控制，也无需担心线程安全问题。这种模型适用于数据不需要修改的场景，例如配置信息、只读缓存等。

代码演示:

public class ReadOnlySharedResourceExample {
    private final Map<String, String> configMap;

    public ReadOnlySharedResourceExample(Map<String, String> config) {
        this.configMap = Collections.unmodifiableMap(new HashMap<>(config));
    }

    public String getConfigValue(String key) {
        return configMap.get(key);
    }
}

这个例子中，configMap是一个只读的映射，它在创建ReadOnlySharedResourceExample对象时被初始化，并且在对象生命周期中不会被修改。多个线程可以并发访问configMap，而无需担心线程安全问题。

2.使用不可变对象

不可变对象是指状态不可变的对象。在创建不可变对象之后，其状态就不能被修改。由于不可变对象的状态是固定的，因此多个线程可以安全地共享这些对象，而无需担心线程安全问题。Java中的String类就是一个典型的不可变对象。

public final class ImmutablePerson {
    private final String name;
    private final int age;

    public ImmutablePerson(String name, int age) {
        this.name = name;
        this.age = age;
    }

    public String getName() {
        return name;
    }

    public int getAge() {
        return age;
    }
}

这个例子中，ImmutablePerson类是一个不可变对象，它的属性name和age在创建对象时被赋值，并且在对象生命周期中不会被修改。多个线程可以并发访问ImmutablePerson对象，而无需担心线程安全问题。

总之，不需要写共享资源的模型和使用不可变对象都是避免线程安全问题的有效方法。这些方法适用于只读或不可变数据的场景，在这些场景下，它们可以大大简化并发编程。

---

三. 直面线程安全的解决思路

1.互斥锁（synchronized）：Java中的synchronized关键字可以用来确保同一时刻只有一个线程能够执行某个方法或代码块。通过使用synchronized关键字，可以实现对共享资源的互斥访问，从而避免多线程间的数据竞争和状态不一致的问题。

2.volatile关键字：volatile关键字可以确保变量在多线程环境下的可见性。当一个线程对volatile变量进行写操作时，其他线程可以立即看到这个变量的最新值。虽然volatile不能保证原子性，但它可以确保线程之间的数据同步。

3.原子操作类（java.util.concurrent.atomic）：Java提供了一组原子操作类，如AtomicInteger、AtomicLong、AtomicReference等，这些类提供了一系列原子操作方法，可以确保在多线程环境下对变量进行原子性操作。

4.隔离：通过将共享资源的访问限制在单个线程内，可以实现线程间的隔离，避免数据竞争。这种方式通常使用ThreadLocal类实现，它可以让每个线程都拥有自己的一个副本，避免了线程之间的资源竞争。

5.不可变对象：创建不可变对象是一种保证线程安全的方法。不可变对象的状态在创建之后就不能被修改，因此在多线程环境下可以安全地共享。Java中的String类就是一个典型的不可变对象。

6.使用线程安全的集合类（java.util.concurrent）：Java提供了一系列线程安全的集合类，如ConcurrentHashMap、CopyOnWriteArrayList等，这些集合类内部已经实现了线程同步机制，可以在多线程环境下安全地使用。

7.分离锁：在某些情况下，可以通过将一个大的锁分成几个小的锁来提高程序的并发性能。这种方法可以有效地减少线程之间的竞争，提高系统的吞吐量。

综上所述，保证线程安全的方法有多种，可以根据具体的场景和需求选择合适的方法来确保程序在多线程环境下的正确性和性能。

以下是几个代码示例，分别解释了上述线程安全策略

1.互斥锁（synchronized）：

public class Counter {
    private int count = 0;

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

    public synchronized int getCount() {
        return count;
    }
}

这个例子中，increment方法和getCount方法都使用了synchronized关键字，确保了在同一时刻只有一个线程可以访问这两个方法。

2.volatile关键字：

public class VolatileFlag {
    private volatile boolean flag = false;

    public void setFlag(boolean value) {
        flag = value;
    }

    public boolean getFlag() {
        return flag;
    }
}

在这个例子中，flag变量被声明为volatile，确保了在多线程环境下该变量的可见性。

3.原子操作类

import java.util.concurrent.atomic.AtomicInteger;

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

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

    public int getCount() {
        return count.get();
    }
}

这个例子中，我们使用了AtomicInteger类来保证increment操作的原子性。

4.隔离（ThreadLocal）：

public class ThreadLocalExample {
    private ThreadLocal<Integer> threadLocalCount = ThreadLocal.withInitial(() -> 0);

    public void increment() {
        threadLocalCount.set(threadLocalCount.get() + 1);
    }

    public int getCount() {
        return threadLocalCount.get();
    }
}

这个例子中，我们使用了ThreadLocal类来保证每个线程都有一个独立的count副本

5.不可变对象：

public final class ImmutablePoint {
    private final int x;
    private final int y;

    public ImmutablePoint(int x, int y) {
        this.x = x;
        this.y = y;
    }

    public int getX() {
        return x;
    }

    public int getY() {
        return y;
    }
}

这个例子中，ImmutablePoint类是不可变的，因为它的状态在创建后不能被修改。

6.线程安全的集合类：

import java.util.concurrent.ConcurrentHashMap;

public class ConcurrentMapExample {
    private ConcurrentHashMap<String, Integer> concurrentMap = new ConcurrentHashMap<>();

    public void put(String key, Integer value) {
        concurrentMap.put(key, value);
    }

    public Integer get(String key) {
        return concurrentMap.get(key);
    }
}

这个例子中，我们使用了ConcurrentHashMap类，它是一个线程安全的集合类。

---

线程的优点

线程作为操作系统调度的基本单位，相较于多进程模型，具有以下优点：

1. 资源共享：在同一进程中的线程共享相同的地址空间和资源，如文件句柄、内存等。这使得线程间的数据交换和通信变得更加容易和高效。而进程之间的资源共享通常需要复杂的进程间通信（IPC）机制。

2. 创建和切换速度快：线程的创建和切换速度通常比进程快。这是因为线程只需分配少量的资源（如堆栈、寄存器等），而进程需要为每个新进程分配独立的地址空间和系统资源。快速的线程切换有助于提高系统的响应速度。

3. 更高的并发性：线程可以充分利用多核处理器的性能，提高并发性。在多核处理器系统中，多个线程可以在不同的核心上同时执行，从而提高系统的整体吞吐量。

4. 更好的资源利用：通过将一个任务分解为多个线程，可以更好地利用系统资源，提高系统的吞吐量和性能。例如，I/O密集型任务可以在一个线程进行I/O操作时，让另一个线程继续执行计算任务。

5. 简化程序设计：在某些情况下，使用多线程可以简化程序设计。例如，在图形用户界面（GUI）应用中，可以使用一个线程处理用户输入，而另一个线程执行后台任务，从而提高程序的响应速度。

需要注意的是，虽然线程具有以上优点，但在多线程环境下编程往往更加复杂。程序员需要处理线程同步、资源竞争、死锁等问题，确保程序在并发环境下的正确性。为了降低多线程编程的难度，可以采用适当的线程安全策略和并发编程模型。