java Thread深入了解(四）

概念介绍

悲观锁是指假设并发更新冲突会发生，所以不管冲突是否真的发生，都会使用锁机制。
相对悲观锁而言，乐观锁机制采取了更加宽松的加锁机制

秒杀案例

下面是模拟秒杀的环境每个返回操作前必须休眠100ms模拟数据库和其他的耗时操作

/**
 * 秒杀服务
 * Created by 51422 on 2017/9/6.
 */
public class MiaoSha {

    public static int goods=10;

    /**
     * 返回订单号
     * @return -1 表示无货 否则货号
     * @throws InterruptedException
     */
    public int getGoods() throws InterruptedException {
        //todo 在这里完成获取货物代码
        Thread.sleep(100);//处理延时100ms
        return -1;
    }
}


/**
 * 测试案例
 */
public void testMiaoSha(){
    final MiaoSha miaoSha=new MiaoSha();
    long st=System.currentTimeMillis();
    ScheduledExecutorService service = Executors.newScheduledThreadPool(500);
    for(int i=0;i<50000;i++){
        service.execute(new Runnable() {
            public void run() {
                try {
                    int good=miaoSha.getGoods();
                    if(good>0){
                        System.out.println("获取到订单"+good);
                    };
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        });
    }
    service.shutdown();
    try {
        service.awaitTermination(2, TimeUnit.DAYS);
    } catch (InterruptedException e) {
        e.printStackTrace();
    }
    System.out.println("耗时"+(System.currentTimeMillis()-st)+"ms");
}

悲观锁处理

/**
 * 秒杀服务
 * Created by 51422 on 2017/9/6.
 */
public class MiaoSha {

    public static int goods=10;

    /**
     * 返回订单号
     * @return -1 表示无货 否则货号
     * @throws InterruptedException
     */
    public int getGoods() throws InterruptedException {
        //todo 在这里完成获取货物代码
        synchronized(this){
            if(goods>0){
                int no=goods;
                goods--;
                Thread.sleep(100);//处理延时100ms
                return no;
            }
            Thread.sleep(100);//处理延时100ms
            return -1;
        }
    }
}

乐观锁处理

/**
 * 秒杀服务
 * Created by 51422 on 2017/9/6.
 */
public class MiaoSha {

    public static int goods=10;
    public static int version=0;

    /**
     * 返回订单号
     * @return -1 表示无货 否则货号
     * @throws InterruptedException
     */
    public int getGoods() throws InterruptedException {
        //todo 在这里完成获取货物代码
        int v=-1;
        if(goods>0&&(v=version)>0){
            if(v==version){
                synchronized(this){
                    if(v==version){
                        version++;
                        int no=goods;
                        goods--;
                        Thread.sleep(100);//处理延时100ms
                        return no;
                    }
                }
            }
        }
        Thread.sleep(100);//处理延时100ms
        return -1;
    }
}

线程进入的时候获取version 同当前version对比如果相同则参加锁竞争竞争获得锁后再次对比version 防止version过期如果version还是同当前版本号相同则获取订单，这样会有效的同步线程，加快服务处理速度且保证货物不会被超发

信号量Semaphore

锁能保证同时只有一个线程使用资源不能让指定个数的线程同时访问资源，这个时候就需要信号量,可以保证指定个数的线程访问资源，达到限流或者限速，比如同时只有2个客户端可以连接到服务器并使用。

public static void SamephoreTest(){
    Semaphore samephore=new Semaphore(2);
    for(int i=0;i<3;i++){
        new Thread(new Runnable() {
            @Override
            public void run() {
                try {
                    samephore.acquire();
                    System.out.println("我访问了！");
                    Thread.sleep(5000);//休眠5s
                    samephore.release();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        }).start();
    }
}

acquire获取许可是个阻塞的方法
release释放许可
acquire和release必须成对出现否则会产生资源死锁