一、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、初始化信号量
1 Semaphore(permits)//初始化许可证数量的构造函数 2 Semaphore(permits,fair)//初始化许可证数量和是否公平模式的构造函数
2、请求信号量
1 acquire()//当前线程尝试去阻塞的获取1个许可证。 2 acquire(permits)//当前线程尝试去阻塞的获取permits个许可证
3、释放信号量
1 release()//当前线程释放1个可用的许可证。 2 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
284
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
