你好,游客 登录 注册 搜索
背景:
阅读新闻

Java高并发编程详解

[日期:2017-09-25] 来源:Linux社区  作者:ghoster [字体: ]

目录:

  1.线程安全单例模式的几种实现方式

  2.同步容器

  3.并发容器

  一、线程安全单例模式的几种实现方式

  1.饿汉式(不使用同步锁,典型的用空间换时间)

public class Singleton1 {  
 
  private static Singleton1 mySingleton = new Singleton1();  

  private Singleton1(){   
      System.out.println("single");  
  }  
     
  public static Singleton1 getSingle(){  
      return mySingleton;  
  }
  
  public static void main(String[] args) {
        Thread[] ths = new Thread[200];
        for(int i=0; i<ths.length; i++) {
            ths[i] = new Thread(()->{
                Singleton1.getSingle();
            });
        }
        
        Arrays.asList(ths).forEach(o->o.start());
    }
} 

运行结果:

  2.懒汉式(使用同步锁,延时加载,典型的时间换空间)

public class Singleton2 {  
    
    private static Singleton2 mySingleton;  
    
    private Singleton2 (){  
         System.out.println("single"); 
    }   
      
    public static synchronized Singleton2 getSingle(){    //对获取实例的方法进行同步
        if (mySingleton == null)     
            mySingleton = new Singleton2(); 
        return mySingleton;
    }
    
    public static void main(String[] args) {
        Thread[] ths = new Thread[200];
        for(int i=0; i<ths.length; i++) {
            ths[i] = new Thread(()->{
                Singleton2.getSingle();
            });
        }
            
        Arrays.asList(ths).forEach(o->o.start());
    }
}  

运行结果:

  3.双重同步锁(缩小粒度,双重检查

public class Singleton3 {  
     
    private volatile static Singleton3 mySingleton;  
     
    private Singleton3 (){
        System.out.println("single");
    }   
     
    public static Singleton3 getSingle(){    //对获取实例的方法进行同步
       if (mySingleton == null){
           synchronized(Singleton3.class){
               if (mySingleton == null)
                   mySingleton = new Singleton3(); 
           }
       }
       return mySingleton;
    }
    
    public static void main(String[] args) {
        Thread[] ths = new Thread[200];
        for(int i=0; i<ths.length; i++) {
            ths[i] = new Thread(()->{
                Singleton3.getSingle();
            });
        }
            
        Arrays.asList(ths).forEach(o->o.start());
    }
}

运行结果:

  为mySingleton加上volatile关键字,以确保能先行发生关系(happens-before relationship),使所有的写操作都发生于读操作之前,避免出现在另一个线程中看到一个初始化一半的mySingleton的情况,同时双重同步锁的效率也很高

  4.使用内部类的单例模式(既不用加锁,也能实现懒加载)

public class Singleton4 {
    
    private Singleton4() {
        System.out.println("single");
    }
    
    private static class Inner {
        private static Singleton4 mySingleton = new Singleton4();
    }
    
    public static Singleton4 getSingle() {
        return Inner.mySingleton;
    }
    
    public static void main(String[] args) {
        Thread[] ths = new Thread[200];
        for(int i=0; i<ths.length; i++) {
            ths[i] = new Thread(()->{
                Singleton4.getSingle();
            });
        }
        
        Arrays.asList(ths).forEach(o->o.start());
    }
    
}

运行结果:

  二、同步容器

  1.vector、stack、hashtable等,保证了方法的原子性

  2.小例子程序演示同步容器

/**
 * 有N张火车票,每张票都有一个编号
 * 同时有10个窗口对外售票
 * 请写一个模拟程序
 * 
 * 分析下面的程序可能会产生哪些问题?
 * 重复销售?超量销售?
 * 
 */
package yxxy.c_024;

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

public class TicketSeller1 {
    static List<String> tickets = new ArrayList<>();
    
    static {
        for(int i=0; i<10000; i++) tickets.add("票编号:" + i);
    }
    
    
    
    public static void main(String[] args) {
        for(int i=0; i<10; i++) {
            new Thread(()->{
                while(tickets.size() > 0) {
                    System.out.println("销售了--" + tickets.remove(0));
                }
            }).start();
        }
    }
}
复制代码

运行结果:

出现了越界情况,说明发生了超量销售与重复销售的情况

下面使用同步容器,以vector为例再做��遍售票操作

/**
 * 有N张火车票,每张票都有一个编号
 * 同时有10个窗口对外售票
 * 请写一个模拟程序
 * 
 * 分析下面的程序可能会产生哪些问题?
 *  
 * 使用Vector或者Collections.synchronizedXXX
 * 分析一下,这样能解决问题吗?
 * 
 */
package yxxy.c_024;

import java.util.Vector;
import java.util.concurrent.TimeUnit;

public class TicketSeller2 {
    static Vector<String> tickets = new Vector<>();
    
    
    static {
        for(int i=0; i<1000; i++) tickets.add("票 编号:" + i);
    }
    
    public static void main(String[] args) {
        
        for(int i=0; i<10; i++) {
            new Thread(()->{
                while(tickets.size() > 0) {
                    
                /*    try {
                        TimeUnit.MILLISECONDS.sleep(10);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }*/
                    
                    
                    System.out.println("销售了--" + tickets.remove(0));
                }
            }).start();
        }
    }
}

运行结果:

...

从运行结果来看,同步容器似乎已经达到了我们想要的目的,但其中还有一些问题

当我们使用了同步容器时,虽然容器的方法是具有原子性的,但当判断与操作分离时,中间的部分还是可能会被其他线程所打断,下面我们模拟一下判断与remove之间有其他的逻辑

/**
 * 有N张火车票,每张票都有一个编号
 * 同时有10个窗口对外售票
 * 请写一个模拟程序
 * 
 * 分析下面的程序可能会产生哪些问题?
 *  
 * 使用Vector或者Collections.synchronizedXXX
 * 分析一下,这样能解决问题吗?
 * 
 */
package yxxy.c_024;

import java.util.Vector;
import java.util.concurrent.TimeUnit;

public class TicketSeller2 {
    static Vector<String> tickets = new Vector<>();
    
    
    static {
        for(int i=0; i<1000; i++) tickets.add("票 编号:" + i);
    }
    
    public static void main(String[] args) {
        
        for(int i=0; i<10; i++) {
            new Thread(()->{
                while(tickets.size() > 0) {
                    
                    try {
                        TimeUnit.MILLISECONDS.sleep(10);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                    
                    
                    System.out.println("销售了--" + tickets.remove(0));
                }
            }).start();
        }
    }
}

运行结果:

我们看到程序出现了错误,所以虽然同步容器保证了方法的原子性,但可能会发生判断与操作分离,整体操作不具备原子性

  三、并发容器

  1.并发容器支持多线程

  ConcurrentSkipListMap跳表结构,他是排好序的容器执行插入操作较快

  ConcurrentHashMap将容器分成了16段,每次执行插入操作的时候只执行其中的一段,而HashTable为锁定一整段

  ConcurrentLinkedQueue无界队列,内存耗不完的情况下可以一直加(offer,add),拿(poll拿出来删掉,peek拿出来不删)

  BolckingQueue阻塞式队列,加(put如果满了就会等待),拿(take如果空了就会等待)

    几个特殊的阻塞式队列:

    1)TransferQueue转移队列,相较于其他队列,多了一个transfer方法生产者将任务直接发给消费者,不进入结束队列,在transfer找不到消费者情形下阻塞,实时处理用的较多,队列还有一定容量

    2)DelayQueue计时任务队列

    3)synchronusQueue同步队列,特殊的transferQueue,没有容量的队列,不能调用add方法,只能调用put方法阻塞等待消费者消费,生产者生产的任务直接给消费者消费

 还是之前的售票程序,现在改用并发容器以ConcurrentLinkedQueue来重新实验一遍

/**
 * 有N张火车票,每张票都有一个编号
 * 同时有10个窗口对外售票
 * 请写一个模拟程序
 * 
 * 使用ConcurrentQueue提高并发性
 */
package yxxy.c_024;

import java.util.Queue;
import java.util.concurrent.ConcurrentLinkedQueue;
import java.util.concurrent.TimeUnit;

public class TicketSeller4 {
    static Queue<String> tickets = new ConcurrentLinkedQueue<>();
    
    
    static {
        for(int i=0; i<1000; i++) tickets.add("票 编号:" + i);
    }
    
    public static void main(String[] args) {
        
        for(int i=0; i<10; i++) {
            new Thread(()->{
                while(true) {
                    String s = tickets.poll();
                    if(s == null) break;
                    else System.out.println("销售了--" + s);
                }
            }).start();
        }
    }
}

运行结果:

当我们改用并发容器ConcurrentLinkedQueue时,我们调用poll方法售票直至票数为0时,字符串s会变为null,所以在接下来的if判断后会跳出

当我们在此例中使用了并发容器时,就具有高的效率同时也不会出现问题

  四、其他常用同步容器

  1.Collocations.synchronizedXXX()将未加锁的容器加锁,在并发度不高的情况下可以使用此方法,在并发度较高且需排序的情况下使用concurrentSkipListMap

  2.CopyOnWriteList写时复制链接表,在读取时不加锁,因此读取的时候效率高,但写的效率特别低,应用场景:在需要大量读取少量写入时使用

  五、总结

  1.对于map/set的使用

    无线程安全要求:hashmap、treemap、linkedhashmap

    并发度低:   hashtable、Collections.synchronizedXXX()

    并发度高:   concurrentHashMap、concurrentSkipListMap

  2.list

    无线程安全要求:ArrayList、LinkedList

    并发度低:   Collections.synchronizedXXX()

    并发度高:   Queue

              concurrentLinkedQueue

              BlockingQueue

                LinkedBQ

                ArrayBQ

                TransferQueue

                synchronusQueue

              DelayQueue

linux
本文评论   查看全部评论 (0)
表情: 表情 姓名: 字数

       

评论声明
  • 尊重网上道德,遵守中华人民共和国的各项有关法律法规
  • 承担一切因您的行为而直接或间接导致的民事或刑事法律责任
  • 本站管理人员有权保留或删除其管辖留言中的任意内容
  • 本站有权在网站内转载或引用您的评论
  • 参与本评论即表明您已经阅读并接受上述条款