并发编程之二

于 2020-04-11 15:31:10 发布
阅读量88 收藏
点赞数
分类专栏： 并发编程 文章标签： java 多线程 并发编程
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/yangweitusgsg/article/details/105453259
版权

2.1 线程之间通信

线程通信概念：线程是操作系统中独立都个体，但这些个体如果不经过特殊的处理就不能成为一个整体，线程间都通信就成为整体的比用方式之一。当线程存在通信指挥，系统间都交互性会更强大，在提高CPU利用率的同时还会使开发人员对线程任务在处理的过程中进行有效的把控与监督。

使用wait/notify方法实现线程间的通信。（注意这两个方法都是object的类方法，换句话说java为所有的对象都提供了这两个方法）

1、wait和notify必须配合synchronized关键字使用。

2、wait方法释放锁，notify方法不释放锁。

示例如下：

package com.bfbc.base.conn008;

import java.util.ArrayList;
import java.util.List;

public class ListAdd1 {

   
   private volatile static List list = new ArrayList();   
   
   public void add(){
      list.add("bjsxt");
   }
   public int size(){
      return list.size();
   }
   
   public static void main(String[] args) {
      
      final ListAdd1 list1 = new ListAdd1();
      
      Thread t1 = new Thread(new Runnable() {
         @Override
         public void run() {
            try {
               for(int i = 0; i <10; i++){
                  list1.add();
                  System.out.println("当前线程：" + Thread.currentThread().getName() + "添加了一个元素..");
                  Thread.sleep(500);
               }  
            } catch (InterruptedException e) {
               e.printStackTrace();
            }
         }
      }, "t1");
      
      Thread t2 = new Thread(new Runnable() {
         @Override
         public void run() {
            while(true){
               if(list1.size() == 5){
                  System.out.println("当前线程收到通知：" + Thread.currentThread().getName() + " list size = 5 线程停止..");
                  throw new RuntimeException();
               }
            }
         }
      }, "t2");     
      
      t1.start();
      t2.start();
   }
   
   
}

 

package com.bfbc.base.conn008;

import java.util.ArrayList;
import java.util.List;
import java.util.Queue;
import java.util.concurrent.CountDownLatch;
import java.util.concurrent.LinkedBlockingDeque;
import java.util.concurrent.LinkedBlockingQueue;
/**
 * wait notfiy 方法，wait释放锁，notfiy不释放锁
 * @author alienware
 *
 */
public class ListAdd2 {
   private volatile static List list = new ArrayList();   
   
   public void add(){
      list.add("bjsxt");
   }
   public int size(){
      return list.size();
   }
   
   public static void main(String[] args) {
      
      final ListAdd2 list2 = new ListAdd2();
      
      // 1 实例化出来一个 lock
      // 当使用wait 和 notify 的时候 ， 一定要配合着synchronized关键字去使用
      //final Object lock = new Object();
      
      final CountDownLatch countDownLatch = new CountDownLatch(1);
      
      Thread t1 = new Thread(new Runnable() {
         @Override
         public void run() {
            try {
               //synchronized (lock) {
                  for(int i = 0; i <10; i++){
                     list2.add();
                     System.out.println("当前线程：" + Thread.currentThread().getName() + "添加了一个元素..");
                     Thread.sleep(500);
                     if(list2.size() == 5){
                        System.out.println("已经发出通知..");
                        countDownLatch.countDown();
                        //lock.notify();
                     }
                  }                 
               //}
            } catch (InterruptedException e) {
               e.printStackTrace();
            }

         }
      }, "t1");
      
      Thread t2 = new Thread(new Runnable() {
         @Override
         public void run() {
            //synchronized (lock) {
               if(list2.size() != 5){
                  try {
                     //System.out.println("t2进入...");
                     //lock.wait();
                     countDownLatch.await();
                  } catch (InterruptedException e) {
                     e.printStackTrace();
                  }
               }
               System.out.println("当前线程：" + Thread.currentThread().getName() + "收到通知线程停止..");
               throw new RuntimeException();
            //}
         }
      }, "t2");  
      
      t2.start();
      t1.start();
      
   }
   
}

2.2 使用wait/notify模拟Queue

BlockingQueue：顾名思义，首先它是一个队列，并且支持阻塞都机制，阻塞都放入和得到数据。我们要实现LinkedBlockingQueue，下面两个简单的方法put和take。

put（anObject）：把anObject加到BlockingQueue里，如果BlockQueue没有空间，则调用此方法都线程被阻断，直到BlockingQueue里面有空间再继续。

take：取走BlockingQueue里排在首位都对象，若BlockingQueue为空，阻断进入等待状态直到BlockingQueue有新的数据被加入。

示例如下：

package com.bfbc.base.conn009;

import java.util.LinkedList;
import java.util.concurrent.TimeUnit;
import java.util.concurrent.atomic.AtomicInteger;

public class MyQueue {
   
   //1 需要一个承装元素的集合 
   private LinkedList<Object> list = new LinkedList<Object>();
   
   //2 需要一个计数器
   private AtomicInteger count = new AtomicInteger(0);
   
   //3 需要制定上限和下限
   private final int minSize = 0;
   
   private final int maxSize ;
   
   //4 构造方法
   public MyQueue(int size){
      this.maxSize = size;
   }
   
   //5 初始化一个对象 用于加锁
   private final Object lock = new Object();
   
   
   //put(anObject): 把anObject加到BlockingQueue里,如果BlockQueue没有空间,则调用此方法的线程被阻断，直到BlockingQueue里面有空间再继续.
   public void put(Object obj){
      synchronized (lock) {
         while(count.get() == this.maxSize){
            try {
               lock.wait();
            } catch (InterruptedException e) {
               e.printStackTrace();
            }
         }
         //1 加入元素
         list.add(obj);
         //2 计数器累加
         count.incrementAndGet();
         //3 通知另外一个线程（唤醒）
         lock.notify();
         System.out.println("新加入的元素为:" + obj);
      }
   }
   
   
   //take: 取走BlockingQueue里排在首位的对象,若BlockingQueue为空,阻断进入等待状态直到BlockingQueue有新的数据被加入.
   public Object take(){
      Object ret = null;
      synchronized (lock) {
         while(count.get() == this.minSize){
            try {
               lock.wait();
            } catch (InterruptedException e) {
               e.printStackTrace();
            }
         }
         //1 做移除元素操作
         ret = list.removeFirst();
         //2 计数器递减
         count.decrementAndGet();
         //3 唤醒另外一个线程
         lock.notify();
      }
      return ret;
   }
   
   public int getSize(){
      return this.count.get();
   }
   
   
   public static void main(String[] args) {
      
      final MyQueue mq = new MyQueue(5);
      mq.put("a");
      mq.put("b");
      mq.put("c");
      mq.put("d");
      mq.put("e");
      
      System.out.println("当前容器的长度:" + mq.getSize());
      
      Thread t1 = new Thread(new Runnable() {
         @Override
         public void run() {
            mq.put("f");
            mq.put("g");
         }
      },"t1");
      
      t1.start();
      
      
      Thread t2 = new Thread(new Runnable() {
         @Override
         public void run() {
            Object o1 = mq.take();
            System.out.println("移除的元素为:" + o1);
            Object o2 = mq.take();
            System.out.println("移除的元素为:" + o2);
         }
      },"t2");
      
      
      try {
         TimeUnit.SECONDS.sleep(2);
      } catch (InterruptedException e) {
         e.printStackTrace();
      }
      
      t2.start();
      
      
   }
   
}

 

2.3 ThreadLocal

ThreadLocal 概念：线程局部变量，是一种多线程建并发访问变量的解决方案。与其synchronized等加锁都方式不同，ThreadLocal完全不提供锁，而使用以空间换时间都手段，为每个线程提供变量的独立副本，以保障线程安全。

从性能上说，ThreadLocal不具有绝对的优势，在并发不是很高的时候，加锁的性能会更好，但作为一套与锁完全无关的线程安全解决方案，在高并发量或者竞争激烈都场景，使用ThreadLocal可以在一定程度上减少锁竞争。

示例如下：

package com.bfbc.base.conn010;

public class ConnThreadLocal {

   public static ThreadLocal<String> th = new ThreadLocal<String>();
   
   public void setTh(String value){
      th.set(value);
   }
   public void getTh(){
      System.out.println(Thread.currentThread().getName() + ":" + this.th.get());
   }
   
   public static void main(String[] args) throws InterruptedException {
      
      final ConnThreadLocal ct = new ConnThreadLocal();
      Thread t1 = new Thread(new Runnable() {
         @Override
         public void run() {
            ct.setTh("张三");
            ct.getTh();
         }
      }, "t1");
      
      Thread t2 = new Thread(new Runnable() {
         @Override
         public void run() {
            try {
               Thread.sleep(1000);
               ct.getTh();
            } catch (InterruptedException e) {
               e.printStackTrace();
            }
         }
      }, "t2");
      
      t1.start();
      t2.start();
   }
   
}

2.4单例与多线程

单例模式，最常见的就是饥饿模式和懒汉模式，一个直接实例化对象，一个在调用方法时进行实例化对象。在对线程模式中，考虑到性能和线程安全问题，我们一般选择下面两种比较经典的单例模式，在性能提高的同时，又保证了线程安全。

1、double check instance

2、static inner class

示例如下：

package com.bfbc.base.conn011;

public class DubbleSingleton {

   private static DubbleSingleton ds;
   
   public  static DubbleSingleton getDs(){
      if(ds == null){
         try {
            //模拟初始化对象的准备时间...
            Thread.sleep(3000);
         } catch (InterruptedException e) {
            e.printStackTrace();
         }
         synchronized (DubbleSingleton.class) {
            if(ds == null){
               ds = new DubbleSingleton();
            }
         }
      }
      return ds;
   }
   
   public static void main(String[] args) {
      Thread t1 = new Thread(new Runnable() {
         @Override
         public void run() {
            System.out.println(DubbleSingleton.getDs().hashCode());
         }
      },"t1");
      Thread t2 = new Thread(new Runnable() {
         @Override
         public void run() {
            System.out.println(DubbleSingleton.getDs().hashCode());
         }
      },"t2");
      Thread t3 = new Thread(new Runnable() {
         @Override
         public void run() {
            System.out.println(DubbleSingleton.getDs().hashCode());
         }
      },"t3");
      
      t1.start();
      t2.start();
      t3.start();
   }
   
}

 

package com.bfbc.base.conn011;

public class Singletion {
   
   private static class InnerSingletion {
      private static Singletion single = new Singletion();
   }
   
   public static Singletion getInstance(){
      return InnerSingletion.single;
   }
   
}
yangweitusgsg
关注
专栏目录
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值