java 多线程之间共享变量

Java多线程之间共享变量

在Java中，多线程是一种非常常见的编程方式，它可以提高程序的运行效率。然而，在多线程编程中，一个重要的问题就是如何处理多个线程之间共享的变量。如果多个线程同时访问一个变量，可能会导致数据不一致的问题，这就是所谓的“竞态条件”。

竞态条件

竞态条件是指多个线程在并发执行时，由于执行顺序不确定导致结果不确定的情况。例如，假设有一个变量count，两个线程同时对这个变量进行自增操作，如果执行顺序不确定，可能会导致count的值不正确。

为了解决这个问题，Java提供了一些机制来保证多线程之间的数据一致性，其中最常用的是synchronized关键字和Lock接口。

使用synchronized关键字

synchronized关键字可以确保在同一时刻只有一个线程可以执行某个代码块，从而避免多个线程同时访问共享变量。下面是一个使用synchronized关键字的示例：

登录后复制

public class Counter {
    private int count = 0;

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

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

• 1.
• 2.
• 3.
• 4.
• 5.
• 6.
• 7.
• 8.
• 9.
• 10.
• 11.

在这个示例中，increment和getCount方法都使用了synchronized关键字，这样可以确保多个线程同时访问这些方法时不会发生竞态条件。

使用Lock接口

除了synchronized关键字外，Java还提供了Lock接口来实现线程同步。使用Lock接口可以更加灵活地控制锁的获取和释放。下面是一个使用Lock接口的示例：

登录后复制

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

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

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

    public int getCount() {
        lock.lock();
        try {
            return count;
        } finally {
            lock.unlock();
        }
    }
}

• 1.
• 2.
• 3.
• 4.
• 5.
• 6.
• 7.
• 8.
• 9.
• 10.
• 11.
• 12.
• 13.
• 14.
• 15.
• 16.
• 17.
• 18.
• 19.
• 20.
• 21.
• 22.
• 23.
• 24.
• 25.

在这个示例中，我们使用了ReentrantLock来创建一个锁，并在increment和getCount方法中使用这个锁来确保线程安全。

代码示例

下面是一个完整的示例，演示了多个线程之间共享一个计数器变量的情况：

登录后复制

import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;

public class Main {
    public static void main(String[] args) {
        Counter counter = new Counter();

        ExecutorService executor = Executors.newFixedThreadPool(4);
        
        for (int i = 0; i < 4; i++) {
            executor.execute(() -> {
                for (int j = 0; j < 10000; j++) {
                    counter.increment();
                }
            });
        }

        executor.shutdown();

        while (!executor.isTerminated()) {
            // waiting for all threads to finish
        }

        System.out.println("Final count: " + counter.getCount());
    }
}

• 1.
• 2.
• 3.
• 4.
• 5.
• 6.
• 7.
• 8.
• 9.
• 10.
• 11.
• 12.
• 13.
• 14.
• 15.
• 16.
• 17.
• 18.
• 19.
• 20.
• 21.
• 22.
• 23.
• 24.
• 25.
• 26.

在这个示例中，我们创建了一个Counter对象，并启动了4个线程来对计数器进行增加操作。最后输出计数器的最终值。

总结

在多线程编程中，共享变量的问题是一个非常重要的问题。为了确保多个线程之间共享变量的一致性，我们可以使用synchronized关键字或Lock接口来实现线程同步。通过合理地处理共享变量，我们可以避免竞态条件，确保程序的正确性和稳定性。

甘特图

下面是一个简单的甘特图，展示了多个线程同时执行增加操作的过程：

原创作者: u_16213412 转载于: https://blog.51cto.com/u_16213412/11390917