多個線程訪問同一個類裏面的靜態成員變量

如下所示，product1, product2,product3是三個不同的線程，但由於Producer類裏面的成員變量count是靜態變量，

所以實際上count是三個線程的共享成員變量，對其進行操作時，最好加上鎖訪問機制。

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

public class BlockingQueueTest {

	public static void main(String[] args) throws InterruptedException {
		// 聲明一個容量爲10的緩存隊列
		BlockingQueue<String> queue = new LinkedBlockingQueue<String>(10);

		Producer producer1 = new Producer(queue, 1);
		Producer producer2 = new Producer(queue, 2);
		Producer producer3 = new Producer(queue, 3);
		Consumer consumer = new Consumer(queue);

		// 藉助Executors
		ExecutorService service = Executors.newCachedThreadPool();
		// 啓動線程
		service.execute(producer1);
		service.execute(producer2);
		service.execute(producer3);
		// service.execute(consumer);

		// 執行10s
		Thread.sleep(10 * 1000);
		producer1.stop();
		producer2.stop();
		producer3.stop();

		Thread.sleep(2000);
		// 退出Executor
		// service.shutdown();
	}
}

package java_thread_delayQueue.blockingqueue;

import java.util.Random;
import java.util.concurrent.BlockingQueue;
import java.util.concurrent.TimeUnit;
import java.util.concurrent.atomic.AtomicInteger;

public class Producer implements Runnable {

	public Producer(BlockingQueue queue, int x) {
		this.queue = queue;
		this.x = x;
	}

	public void run() {
		String data = null;
		Random r = new Random();

		System.out.println("啓動生產者線程！");
		try {
			while (isRunning) {
				System.out.println("正在生產數據...");
				Thread.sleep(r.nextInt(DEFAULT_RANGE_FOR_SLEEP));

				data = "線程"+ x +"data:" + count.incrementAndGet();
				System.out.println("將數據：" + data + "放入隊列...");
				System.out.println(data);
				if (!queue.offer(data, 2, TimeUnit.SECONDS)) {
					System.out.println("放入數據失敗：" + data);
				}
			}
		} catch (InterruptedException e) {
			e.printStackTrace();
			Thread.currentThread().interrupt();
		} finally {
			System.out.println("退出生產者線程！");
		}
	}

	public void stop() {
		isRunning = false;
	}

	private volatile boolean isRunning = true;
	private BlockingQueue queue;
	private static AtomicInteger count = new AtomicInteger();
	private static final int DEFAULT_RANGE_FOR_SLEEP = 1000;
	
	private int x;

}