使用无锁完成多线程模拟售票, 理解无锁是啥?

时间：2019-10-19 13:25:04 阅读：98 评论：0 收藏：0 [点我收藏+]

标签：tac hat 使用 void for else ble 就是 over

实现的模拟多线程实现售票是每个学习多线程的初学者必须要学会掌握的知识点, 既然掌握的它, 我们自然要举一反三

So~, 无锁版出现了

What无锁?

假如两个线程同时修改一个变量的场景下

我们需要三个值, 预期值(线程副本变量中的值), 主存值(从主存变量中的值), 新值(我们要设置的值)

如果预期值不等于主存值则忽略新值写入 =========> 这句话是一个原子操作, 是不可分割的(就是内存屏障), 在执行这个过程中, 是不会失去时间片的

如果预期值等于主存值则新值写入 =========> 这句话是一个原子操作, 是不可分割的(就是内存屏障), 在执行这个过程中, 是不会失去时间片的

技术图片

直接上代码就能理解了, 这是多线程模拟售票的案例, 里面有无锁和加锁的案例

package com.zhazha.juc;

import org.junit.Test;
import java.util.concurrent.CountDownLatch;
import java.util.concurrent.atomic.AtomicInteger;
import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;

/**
 * @author zhazha
 * @version 1.0.0
 * @date 2019/10/19 9:39
 * @msg
 **/
public class TestTicketAtomicLock {

    @Test
    public void test01() throws Exception {
        CountDownLatch latch = new CountDownLatch(3);
        TicketAtomic ticket = new TicketAtomic(latch);
        for (int i = 0; i < 3; i++) {
            new Thread(ticket).start();
        }
        latch.await();
    }

    @Test
    public void test() throws Exception {
        CountDownLatch latch = new CountDownLatch(3);
        TicketNonAtomic ticket = new TicketNonAtomic(latch);
        for (int i = 0; i < 3; i++) {
            new Thread(ticket).start();
        }
        latch.await();
    }

}


class TicketAtomic implements Runnable {

    private AtomicInteger ticket = new AtomicInteger(100);
    private CountDownLatch latch;

    public TicketAtomic(CountDownLatch latch) {
        this.latch = latch;
    }

    @Override
    public void run() {
        while (true) {
            try {
                int temp = ticket.get();
                if (temp > 0) {
                    // TimeUnit.MILLISECONDS.sleep(100);
                    if (ticket.compareAndSet(temp, ticket.get() - 1)) {
                        System.out.println(Thread.currentThread().getName() + " \t成功售票, 余票为: " + ticket.get());
                    }
                }
                else {
                    break;
                }
            }
            catch (Exception e) {
                e.printStackTrace();
            }
        }
        latch.countDown();
    }
}


class TicketNonAtomic implements Runnable {

    private Integer ticket = 100;
    private Lock lock = new ReentrantLock();
    private CountDownLatch latch;

    public TicketNonAtomic(CountDownLatch latch) {
        this.latch = latch;
    }

    @Override
    public void run() {
        while (true) {
            lock.lock();
            try {
                if (ticket > 0) {
                    // TimeUnit.MILLISECONDS.sleep(100);
                    System.out.println(Thread.currentThread().getName() + " \t成功售票, 余票为: " + --ticket);
                }
                else {
                    break;
                }
            } catch (Exception e) {
                e.printStackTrace();
            } finally {
                lock.unlock();
            }
        }
        latch.countDown();
    }
}

上面无锁代码中, 最重要的是这句话

if (ticket.compareAndSet(temp, ticket.get() - 1)) {

内部代码

技术图片

再进去就是用c++实现的无锁