java架构《并发线程基础二》

1、关键字 volatile
          使用场景：针对与多线程公用的数据用volatile关键字修饰但其不保证原子性（同步）。volatile关键字不具备synchronized关键
                                字的原子性（同步）
          实例讲解：在一个类，启动一个线程，在线程里面判断如果全局公用的数据发生改变的时候，立即停止线程。

2、关键字 wait notfiy 方法，wait释放锁，notfiy不释放锁
          注意事项：当使用wait 和 notify 的时候，一定要配合着synchronized关键字去使用
            解决不释放锁的方式：

   　　　　　　　　　　　　　　　　使用import java.util.concurrent.CountDownLatch;的CountDownLatch类

                               countDownLatch.countDown(); 相当于 notfiy；   countDown()会释放锁

                               countDownLatch.await();相当于 wait；

3、队列 Queue

 　　　　　　　　　　　　 BlockingQueue（有界阻塞队列）：put(Object): 把Object加到BlockingQueue里,如果BlockQueue没有空间,则调用此方法的线程

                                       被阻断，直到BlockingQueue里面有空间再继续.removeFirst();取走BlockingQueue里排在首位的对象,若

                                       BlockingQueue为空,阻断进入等待状态直到BlockingQueue有新的数据被加入.

4、关键字ThreadLocal
使用场景：ThreadLocal修饰的集合或者属性只在当前线程有效

5、单例模式

 1    public class DubbleSingleton {

 2

 3

 4 　　private static DubbleSingleton ds;

 5

 6 　　public  static DubbleSingleton getDs(){

 7 　　if(ds == null){

 8 　　try {

 9 　　//模拟初始化对象的准备时间...

10 　　Thread.sleep(3000);

11 　　} catch (InterruptedException e) {

12 　　e.printStackTrace();

13 　　}

14 　　synchronized (DubbleSingleton.class) {

15 　　if(ds == null){

16 　　ds = new DubbleSingleton();

17 　　}

18   　　  }

19         }

20         return ds;

21                }

22                    }

6、内部类处理线程安全

 1   public class Singletion {

 2

 3 　　private static class InnerSingletion {

 4 　　private static Singletion single = new Singletion();

 5 　　}

 6

 7 　　public static Singletion getInstance(){

 8 　　return InnerSingletion.single;

 9 　　}

10

11     }

7、Vector 和HashTable 集合，多线程使用Vector或者HashTable的示例（简单线程同步问题）

　　使用场景：初始化火车票池并添加火车票:避免线程同步可采用Vector替代ArrayList HashTable替代HashMap

8、ConcurrentHashMap 集合
              　　使用场景：存在相同key 第二次Key保存就会失败但不会有异常

9、 LinkedBlockingQueue队列
             　　使用场景：阻塞无界队列 peekFirst获取到第一个元素但不移除 pollLast获取到最后一个元素会移除
              　　注意：初始化没有长度表示无界有长度，表示有界

10、 PriorityBlockingQueue队列
           　　   使用场景：根据一定规则，自动排序
             　　注意事项：机制：队列使用.take()方法时，自动重新排序如果直接保存，然后for循环打印，不会自动排序

11、 ConcurrentLinkedQueue 高性能无阻塞无界队列
                　　使用场景：高并发高性能数据集合
使用方式：

　　　　　　　　　　　　　　　　　　　　　　 增加元素：add(object)  或 offer(object);

                                     移除元素：poll()   从头部取出元素，并从队列里删除

                                     获取元素：peek()   从头部取出元素

12、ArrayBlockingQueue 有界队列初始化必须传长度
　使用方式：array.offer("a", 2, TimeUnit.SECONDS); //2S 内加入a 如果加入成功返回true 否则返回false
注意事项： offer put add都是阻塞的

13、LinkedBlockingQueue 阻塞队列初始化可以不传长度不传变成无界队列
特别使用方式：

　　　　　　　　　　　　　 a.drainTo(list,N)     表示：从队列里面抽出N个元素放在list集合里面

                      a：表示LinkedBlockingQueue  队列  list为新建的list集合   n：元素个数

14、SynchronousQueue 没有大小的队列。
使用场景：在特定的日期，不需要队列的时候，要提高性能时，就可以使用SynchronousQueue 。相当于在队列中过一下
实例：//SynchronousQueue没有大小相当于只是在其中通过一下

 1 　final SynchronousQueue<String> q = new SynchronousQueue<String>();

 2 　　Thread t1 = new Thread(new Runnable() {

 3 　　@Override

 4 　　public void run() {

 5 　　try {

 6 　　System.out.println(q.take());

 7 　　} catch (InterruptedException e) {

 8 　　e.printStackTrace();

 9 　　}

10 　　}

11 　　});

12 　　t1.start();

13 　　Thread t2 = new Thread(new Runnable() {

14

15 　　@Override

16 　　public void run() {

17 　　q.add("asdasd");

18 　　}

19 　　});

20 　　t2.start();

21     }

22

23

24

巴特西

java架构《并发线程基础二》

最新文章

热门文章