译 -- Java 并发编程（多线程）二 | Producer-Consumer | Get status of all threads | deadlocked

最新推荐文章于 2024-04-03 18:04:12 发布

研发之道

最新推荐文章于 2024-04-03 18:04:12 发布

阅读量551

点赞数

分类专栏：并发多线程翻译文章文章标签：多线程并发

并发多线程同时被 2 个专栏收录

13 篇文章

订阅专栏

翻译文章

9 篇文章

订阅专栏

接着译 – Java 并发编程（多线程）一

创建基本的死锁系统

当两个竞争动作都在等待对方完成时出现死锁，因此都不会完成工作，在java中每个对象都关联一把锁，为了避免多个线程在单个对象上并发的做修改，我们能够使用synchronized 原语，但是一切都将会带来消耗，错误的使用synchronized 原语将会导致“卡死”系统, 称之为死锁。

考虑有两个线程工作在一个实例上，把线程叫做First和 Second，有2个资源R1和R2， First占有R1 并且它的完成需要R2，然而第二个占有R2并且它的完成需要R1.
所以在时间t = 0。
First 有R1 并且Second 有R2，现在First等待R2 然而Second等待R1，这个等待是无限的，并且这将导致死锁。

public class Example2 {

    public static void main(String[] args) throws InterruptedException {
        final DeadLock dl = new DeadLock();
        Thread t1 = new Thread(new Runnable() {

            @Override
            public void run() {
                // TODO Auto-generated method stub
                dl.methodA();
            }
        });

        Thread t2 = new Thread(new Runnable() {

            @Override
            public void run() {
                // TODO Auto-generated method stub
                try {
                    dl.method2();
                } catch (InterruptedException e) {
                    // TODO Auto-generated catch block
                    e.printStackTrace();
                }
            }
        });
        t1.setName("First");
        t2.setName("Second");
        t1.start();
        t2.start();
    }
}

class DeadLock {

    Object mLock1 = new Object();
    Object mLock2 = new Object();


    public void methodA() {
        System.out.println("methodA wait for mLock1  " + Thread.currentThread().getName());
        synchronized (mLock1) {
            System.out.println("methodA mLock1 acquired   " + Thread.currentThread().getName());
            try {
                Thread.sleep(100);
                method2();
            } catch (InterruptedException e) {
                // TODO Auto-generated catch block
                e.printStackTrace();
            }
        }
    }
    public void method2() throws InterruptedException {
        System.out.println("method2 wait for mLock2  " + Thread.currentThread().getName());
        synchronized (mLock2) {
            System.out.println("method2  mLock2 acquired   " + Thread.currentThread().getName());
            Thread.sleep(100);
            method3();
        }
    }
    public void method3() throws InterruptedException {
        System.out.println("method3  mLock1  "+ Thread.currentThread().getName());
        synchronized (mLock1) {
            System.out.println("method3   mLock1 acquired  " + Thread.currentThread().getName());
        }
    }
}

程序输出：

methodA wait for mLock1  First
method2 wait for mLock2  Second
method2  mLock2 acquired   Second
methodA mLock1 acquired   First
method3  mLock1  Second
method2 wait for mLock2  First

在线程中并行执行

public class SimpleThread {

    public static void main(String[] args) {
        Thread thread = new Thread() {
            @Override
            public void run() {
                show_messages();
            }
        };
        thread.start();

        System.out.println("I start the Thread and i finished my job");
    }

    private static void show_messages() {
        for (int i = 0; i < 10; i++) {
            try {
                System.out.println("Hello, i'm THREAD");
                Thread.sleep(1000);
            } catch (Exception e) {
                System.out.println("Exception = " + e);
            }
        }
    }
}

结果:

I start the Thread and i finished my job

Hello, i'm THREAD

Hello, i'm THREAD

Hello, i'm THREAD

Hello, i'm THREAD

Hello, i'm THREAD

Hello, i'm THREAD

Hello, i'm THREAD

Hello, i'm THREAD

Hello, i'm THREAD

Hello, i'm THREAD

获取被应用程序启动的线程的状态除了系统线程

代码片段：

import java.util.Set;

public class ThreadStatus {
    public static void main(String args[]) throws Exception {
        for (int i = 0; i < 5; i++){
            Thread t = new Thread(new MyThread());
            t.setName("MyThread:" + i);
            t.start();
        }
        int threadCount = 0;
        Set<Thread> threadSet = Thread.getAllStackTraces().keySet();
        for (Thread t : threadSet) {
            if (t.getThreadGroup() == Thread.currentThread().getThreadGroup()) {
                System.out.println("Thread :" + t + ":" + "state:" + t.getState());
                ++threadCount;
            }
        }
        System.out.println("Thread count started by Main thread:" + threadCount);
    }
}

class MyThread implements Runnable {
    public void run() {
        try {
            Thread.sleep(2000);
        } catch(Exception err) {
            err.printStackTrace();
        }
    }
}

Output:

Thread :Thread[MyThread:1,5,main]:state:TIMED_WAITING
Thread :Thread[MyThread:3,5,main]:state:TIMED_WAITING
Thread :Thread[main,5,main]:state:RUNNABLE
Thread :Thread[MyThread:4,5,main]:state:TIMED_WAITING
Thread :Thread[MyThread:0,5,main]:state:TIMED_WAITING
Thread :Thread[MyThread:2,5,main]:state:TIMED_WAITING
Thread count started by Main thread:6

解释：
Thread.getAllStackTraces().keySet() 返回所有线程，包括应用程序线程和系统线程。如果你仅仅对被应用程序启动的线程的状态。遍历线程组通过检查一个特定线程的线程组是否是main线程的线程组。
缺乏上述线程组条件，程序返回下述系统线程的状态：

Reference Handler
Signal Dispatcher
Attach Listener
Finalizer

多个共享全局队列的producer /consumer 示例

下面代码显示多个Producer / Consumer 程序，所有的Producer / Consumer 线程共享全局队列

import java.util.concurrent.*;
import java.util.Random;

public class ProducerConsumerWithES {
    public static void main(String args[]) {
        BlockingQueue<Integer> sharedQueue = new LinkedBlockingQueue<Integer>();

        ExecutorService pes = Executors.newFixedThreadPool(2);
        ExecutorService ces = Executors.newFixedThreadPool(2);

        pes.submit(new Producer(sharedQueue, 1));
        pes.submit(new Producer(sharedQueue, 2));
        ces.submit(new Consumer(sharedQueue, 1));
        ces.submit(new Consumer(sharedQueue, 2));

        pes.shutdown();
        ces.shutdown();
    }
}

/* Different producers produces a stream of integers continuously to a shared queue, 
which is shared between all Producers and consumers */

class Producer implements Runnable {
    private final BlockingQueue<Integer> sharedQueue;
    private int threadNo;
    private Random random = new Random();
    public Producer(BlockingQueue<Integer> sharedQueue,int threadNo) {
        this.threadNo = threadNo;
        this.sharedQueue = sharedQueue;
    }
    @Override
    public void run() {
        // Producer produces a continuous stream of numbers for every 200 milli seconds
        while (true) {
            try {
                int number = random.nextInt(1000);
                System.out.println("Produced:" + number + ":by thread:"+ threadNo);
                sharedQueue.put(number);
                Thread.sleep(200);
            } catch (Exception err) {
                err.printStackTrace();
            }
        }
    }
}
/* Different consumers consume data from shared queue, which is shared by both producer and consumer threads */
class Consumer implements Runnable {
    private final BlockingQueue<Integer> sharedQueue;
    private int threadNo;
    public Consumer (BlockingQueue<Integer> sharedQueue,int threadNo) {
        this.sharedQueue = sharedQueue;
        this.threadNo = threadNo;
    }
    @Override
    public void run() {
        // Consumer consumes numbers generated from Producer threads continuously
        while(true){
            try {
                int num = sharedQueue.take();
                System.out.println("Consumed: "+ num + ":by thread:"+threadNo);
            } catch (Exception err) {
               err.printStackTrace();
            }
        }
    }   
}

输出：

Produced:69:by thread:2
Produced:553:by thread:1
Consumed: 69:by thread:1
Consumed: 553:by thread:2
Produced:41:by thread:2
Produced:796:by thread:1
Consumed: 41:by thread:1
Consumed: 796:by thread:2
Produced:728:by thread:2
Consumed: 728:by thread:1

等等。。。。
解释：

sharedQueue 是一个LinkedBlockingQueue 被所有Producer 和 Consumer 线程共享。
Producer 线程连续的每200milli生产一个整数，并且追加到sharedQueue
Consumer 线程从sharedQueue 不断的中消费整数
这个程序被实现为没有显式的synchronized 或 Lock 设计。BlockingQueue 是实现它的关键。

BlockingQueue 实现被设计为主要用于生产者-消费者队列。
BlockingQueue 是线程安全的。所有的队列方法使用内部的lock 或其它的并发控制形式来自动的实现它们的作用。

Producer-Consumer

一个简单的生产者消费者问题解决方案示例。注意到JDK的类（AtomicBoolean 和 BlockingQueue）被用于同步，并减少了创建无效解决方案的机会。
查阅 BlockingQueue 的各种类型的Javadoc ，选择不同的实现可能奇幻的改变这个示例的行为（like DelayQueue or Priority Queue）

public class Producer implements Runnable {

    private final BlockingQueue<ProducedData> queue;

    public Producer(BlockingQueue<ProducedData> queue) {
        this.queue = queue;
    }

    public void run() {
        int producedCount = 0;
        try {
            while (true) {
                producedCount++;
                //put throws an InterruptedException when the thread is interrupted
                queue.put(new ProducedData());
            }
        } catch (InterruptedException e) {
            // the thread has been interrupted: cleanup and exit
            producedCount--;
            //re-interrupt the thread in case the interrupt flag is needeed higher up
            Thread.currentThread().interrupt();
        }
        System.out.println("Produced " + producedCount + " objects");
    }
}

public class Consumer implements Runnable {

    private final BlockingQueue<ProducedData> queue;

    public Consumer(BlockingQueue<ProducedData> queue) {
        this.queue = queue;
    }

    public void run() {
        int consumedCount = 0;
        try {
            while (true) {
                //put throws an InterruptedException when the thread is interrupted
                ProducedData data = queue.poll(10, TimeUnit.MILLISECONDS);
                // process data
                consumedCount++;
            }
        } catch (InterruptedException e) {
            // the thread has been interrupted: cleanup and exit
            consumedCount--;
            //re-interrupt the thread in case the interrupt flag is needeed higher up
            Thread.currentThread().interrupt();
        }
        System.out.println("Consumed " + consumedCount + " objects");
    }
}


public class ProducerConsumerExample {
    static class ProducedData {    
        // empty data object
    }

    public static void main(String[] args) throws InterruptedException {
        BlockingQueue<ProducedData> queue = new ArrayBlockingQueue<ProducedData>(1000);
        // choice of queue determines the actual behavior: see various BlockingQueue implementations

        Thread producer = new Thread(new Producer(queue));
        Thread consumer = new Thread(new Consumer(queue));

        producer.start();
        consumer.start();

        Thread.sleep(1000);
        producer.interrupt();
        Thread.sleep(10);
        consumer.interrupt();
    }
}