java使用synchronized与Semaphore解决生产者消费者问题对比

一、synchronized与信号量Semaphore简介

　　1、synchronized是java中的关键字，是用来控制线程同步的问题最常用的方法。

　　2、Semaphore是属于java的一个类，同样是用来控制多个线程同步问题。

二、两者用法比较

　　使用synchronized控制多线程的话，同时只有一个线程去访问资源。就是消费者与生产者两个线程同时只有其中一个处理产品。

　　Semaphore可以实现synchronized的功能与synchronized不能实现的功能。假如消费者和生产者线程都有3个，并且能同时运行，使用synchronized控制的话，同时只能有一个线程运行，而Semaphore能够满足多个消费者或生产者同时进行消费或生产，能够控制同时在运行的线程和其数量，提高效率和性能。

三、代码比较

　　1、synchronized实现生产者消费者问题

package Synchronized;

import java.util.LinkedList;

public class ProducerAndConsumer {
    private static final int size=1;//产品最大的数量
    private LinkedList<String> product;//存放产品的链表
    private Producer producer;
    private Consumer consumer;

    public ProducerAndConsumer() {
        product=new LinkedList<String>();
        producer=new Producer();
        consumer=new Consumer();
        //线程开始
        new Thread(producer).start();
        new Thread(consumer).start();

    }

    public static void main(String[] args) {
        ProducerAndConsumer pac=new ProducerAndConsumer();
    }
    class Producer implements Runnable{

        @Override
        public void run() {
            while(true)
            {
                synchronized (product) {
                    try {
                        if (product.size()==size) {//产品数量达到最大时等待
                            product.wait();
                        }
                        System.out.println("生产者正在生产。。。");
                        Product p=new Product((int)(Math.random()*1000000));//产品的随机
                        Thread.sleep(1000);//假设生产产品的时间
                        product.add("产品"+p.geti());
                        System.out.println("产品"+p.geti()+"生产完成");
                        product.notify();//释放锁
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }

                }
            }

        }

    }

    class Consumer implements Runnable{

        @Override
        public void run() {
            while(true)
            {
                synchronized (product) {
                    try {
                        if (product.isEmpty()) {//产品数量为0时等待
                            product.wait();
                        }
                        System.out.println("消费者正在消费。。。");
                        Thread.sleep(1000);
                        String p=product.remove();
                        System.out.println(p+"消费完成");
                        product.notify();
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }
            }

        }

    }

    class Product{//产品类
        int i;
        public Product(int i)
        {
            this.i=i;
        }
        public int geti()
        {
            return i;
        }
    }

}

　　2、Semaphore实现消费者生产者问题

package Semaphore;

import java.util.LinkedList;
import java.util.concurrent.Semaphore;

public class ProducerAndConsumer {
    private static final int size=10;//产品池存放最大数量
    private Semaphore empty;//产品池中空的数量，生产者请求empty，消费者释放empty
    private Semaphore mutex;//控制只有一个线程进入产品池对产品操作
    private Semaphore full;//产品池中满的数量，生产者释放full，消费者请求empty
    private LinkedList<String> product;//存放产品的链表，即产品池
    private Producer producer;
    private Consumer consumer;

    public ProducerAndConsumer() {
        empty=new Semaphore(size);//初始为最大数量size
        mutex=new Semaphore(1);//初始为1
        full=new Semaphore(0);//初始为0
        product=new LinkedList<String>();

        producer=new Producer();
        consumer=new Consumer();
        new Thread(producer).start();
        new Thread(consumer).start();

    }

    public static void main(String[] args) {
        ProducerAndConsumer pac=new ProducerAndConsumer();
    }
    class Producer implements Runnable
    {

        @Override
        public void run() {
            do {
                try {
                    empty.acquire();//请求empty信号量
                    mutex.acquire();//请求mutex信号量
                    System.out.println("生产者正在生产。。。");
                    Thread.sleep(1000);
                    Product p=new Product((int)(Math.random()*1000000));
                    product.add("产品"+p.geti());
                    System.out.println("产品"+p.geti()+"生产完成");
                    mutex.release(1);//释放mutex信号量
                    full.release(1);//释放full信号量
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            } while (true);
        }

    }

    class Consumer implements Runnable
    {

        @Override
        public void run() {
            do {
                try {
                    full.acquire();//请求full信号量
                    mutex.acquire();//请求mutex信号量
                    System.out.println("消费者正在消费。。。");
                    Thread.sleep(1000);
                    String s=product.remove();
                    System.out.println(s+"消费完成");
                    mutex.release(1);//释放mutex信号量
                    empty.release(1);//释放empty信号量
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            } while (true);
        }

    }

    class Product
    {
        int i;
        public Product(int i)
        {
            this.i=i;
        }
        public int geti()
        {
            return i;
        }
    }
}

　　3、Semaphore实现多个生产者和消费者同时运行的问题

　　假设产品池最大数量为10，同时运行的线程数最多为2

package Semaphore;

import java.util.LinkedList;
import java.util.concurrent.Semaphore;

public class ProducerAndConsumer {
    private static final int size=10;//产品池存放最大数量
    private Semaphore empty;//产品池中空的数量，生产者请求empty，消费者释放empty
    private Semaphore mutex;//控制只有一个线程进入产品池对产品操作
    private Semaphore full;//产品池中满的数量，生产者释放full，消费者请求empty
    private LinkedList<String> product;//存放产品的链表，即产品池
    private Producer producer;
    private Consumer consumer;

    public ProducerAndConsumer() {
        empty=new Semaphore(size);//初始为最大数量size
        mutex=new Semaphore(2);//修改此处控制同时运行的线程数量
        full=new Semaphore(0);//初始为0
        product=new LinkedList<String>();

        producer=new Producer();
        consumer=new Consumer();
        //有4个线程请求共同操作共享资源
        new Thread(producer).start();
        new Thread(consumer).start();
        new Thread(producer).start();
        new Thread(consumer).start();

    }

    public static void main(String[] args) {
        ProducerAndConsumer pac=new ProducerAndConsumer();
    }
    class Producer implements Runnable
    {

        @Override
        public void run() {
            do {
                try {
                    empty.acquire();//请求empty信号量
                    mutex.acquire();//请求mutex信号量
                    System.out.println("生产者"+Thread.currentThread().getName()+"正在生产。。。");
                    Thread.sleep(1000);
                    Product p=new Product((int)(Math.random()*1000000));
                    product.add("产品"+p.geti());
                    System.out.println("产品"+p.geti()+"生产完成");
                    mutex.release(1);//释放mutex信号量
                    full.release(1);//释放full信号量
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            } while (true);
        }

    }

    class Consumer implements Runnable
    {

        @Override
        public void run() {
            do {
                try {
                    full.acquire();//请求full信号量
                    mutex.acquire();//请求mutex信号量
                    System.out.println("消费者"+Thread.currentThread().getName()+"正在消费。。。");
                    Thread.sleep(1000);
                    String s=product.remove();
                    System.out.println(s+"消费完成");
                    mutex.release(1);//释放mutex信号量
                    empty.release(1);//释放empty信号量
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            } while (true);
        }

    }

    class Product
    {
        int i;
        public Product(int i)
        {
            this.i=i;
        }
        public int geti()
        {
            return i;
        }
    }
}

三、Semaphore用法简介

　　1、初始化信号量

 Semaphore(permits)//初始化许可证数量的构造函数
 Semaphore(permits,fair)//初始化许可证数量和是否公平模式的构造函数

　　2、请求信号量

 acquire()//当前线程尝试去阻塞的获取1个许可证。
 acquire(permits)//当前线程尝试去阻塞的获取permits个许可证

　　3、释放信号量

 release()//当前线程释放1个可用的许可证。
 release(permits)//当前线程释放permits个可用的许可证。

相关链接：https://blog.csdn.net/hanchao5272/article/details/79780045

　　　　　https://www.cnblogs.com/XHJT/p/3910406.html

四、总结

　　结合自己的学习过程，写下了自己如何学习多线程的经典问题，还有很多的问题没有弄清楚，希望能够继续加油！！！（我要一步一步往上爬，等待阳光看着它的脸，小小的天有大大的梦想，重重的壳裹着轻轻的仰望----------周杰伦《蜗牛》）

转载注明出处：https://www.cnblogs.com/chenglin520/p/JayCL.html