不同线程 传递变量 java

不同线程 传递变量 Java

在多线程编程中，很常见的情况是需要在不同线程之间传递变量。Java提供了多种方法来实现这一目的。本文将介绍几种常见的方法，并通过代码示例进行演示。

1. 共享变量

最简单的方法是使用共享变量。共享变量是在多个线程中可见的变量，可以被多个线程同时访问和修改。Java中的基本数据类型和引用类型（如数组和对象）都可以作为共享变量。

下面是一个使用共享变量的示例代码：

public class SharedVariableExample {
    private static int count = 0;
    
    public static void main(String[] args) {
        Thread thread1 = new Thread(() -> {
            for (int i = 0; i < 1000; i++) {
                count++;
            }
        });

        Thread thread2 = new Thread(() -> {
            for (int i = 0; i < 1000; i++) {
                count++;
            }
        });

        thread1.start();
        thread2.start();

        try {
            thread1.join();
            thread2.join();
        } catch (InterruptedException e) {
            e.printStackTrace();
        }

        System.out.println("Count: " + count);
    }
}

上述代码创建了两个线程，在每个线程中循环1000次，每次循环都对共享变量count进行递增操作。最后输出count的值。由于两个线程同时对count进行操作，因此最终的结果会受到线程之间的竞争关系影响。

然而，共享变量存在线程安全问题。在上述示例中，由于两个线程同时对count进行递增操作，可能会导致数据竞争，从而得到不正确的结果。为了避免这种情况，我们可以使用锁机制。

2. 锁机制

锁机制可以确保同一时间只有一个线程能够访问共享变量，从而避免数据竞争。Java中提供了synchronized关键字和Lock接口来实现锁机制。

下面是一个使用synchronized的示例代码：

public class SynchronizedExample {
    private static int count = 0;

    public static void main(String[] args) {
        Object lock = new Object();

        Thread thread1 = new Thread(() -> {
            synchronized (lock) {
                for (int i = 0; i < 1000; i++) {
                    count++;
                }
            }
        });

        Thread thread2 = new Thread(() -> {
            synchronized (lock) {
                for (int i = 0; i < 1000; i++) {
                    count++;
                }
            }
        });

        thread1.start();
        thread2.start();

        try {
            thread1.join();
            thread2.join();
        } catch (InterruptedException e) {
            e.printStackTrace();
        }

        System.out.println("Count: " + count);
    }
}

上述代码使用了一个共享的对象lock作为锁。在每个线程中，通过synchronized (lock)来获取锁，从而确保同一时间只有一个线程能够执行对共享变量count的操作。

除了synchronized关键字，还可以使用Lock接口来实现锁机制。Lock接口提供了更灵活的锁操作，例如可重入锁、公平锁等。下面是一个使用Lock接口的示例代码：

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

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

    public static void main(String[] args) {
        Thread thread1 = new Thread(() -> {
            lock.lock();
            try {
                for (int i = 0; i < 1000; i++) {
                    count++;
                }
            } finally {
                lock.unlock();
            }
        });

        Thread thread2 = new Thread(() -> {
            lock.lock();
            try {
                for (int i = 0; i < 1000; i++) {
                    count++;
                }
            } finally {
                lock.unlock();
            }
        });

        thread1.start();
        thread2.start();

        try {
            thread1.join();
            thread2.join();
        } catch (InterruptedException e) {
            e.printStackTrace();
        }

        System.out.println("Count: " + count);
    }
}

上述代码使用了ReentrantLock类实