swaggyW's Blog

public ThreadPoolExecutor(int corePoolSize,
                          int maximumPoolSize,
                          long keepAliveTime,
                          TimeUnit unit,
                          BlockingQueue<Runnable> workQueue,
                          ThreadFactory threadFactory,
                          RejectedExecutionHandler handler) {
    if (corePoolSize < 0 ||
        maximumPoolSize <= 0 ||
        maximumPoolSize < corePoolSize ||
        keepAliveTime < 0)
        throw new IllegalArgumentException();
    if (workQueue == null || threadFactory == null || handler == null)
        throw new NullPointerException();
    this.corePoolSize = corePoolSize;
    this.maximumPoolSize = maximumPoolSize;
    this.workQueue = workQueue;
    this.keepAliveTime = unit.toNanos(keepAliveTime);
    this.threadFactory = threadFactory;
    this.handler = handler;
}

corePoolSize #the number of threads to keep in the pool, even if they are idle, unless {@code allowCoreThreadTimeOut} is set //保留在池中的线程数量，即使它们空闲，除非设置了容许核心线程超时。核心线程数，最少的线程数
maximumPoolSize: 即池中允许的最大线程数
keepAliveTime & TimeUnit: 当线程数大于核心线程数时，空闲线程在终止前等待新任务的时间，就是空闲线程的存活时间， 后面是规定的单位
BlockingQueue:  线程的阻塞队列，用来存放那些被方法提交但是还没有执行的任务
ThreadFactory: 执行器创建一个线程使用的线程工厂
RejectedExecutionHandler: 当线程池满了或者阻塞队列满了的时候，有新任务提交过来时，执行的拒绝策略

@PostMapping("/oreder/createOrder")
public Result createOrder(@RequestBody OrderVo orderVo) {
    String orderId = orderService.createOrder(orderVo);
    if (orderId != null) {
        //调用库存服务进行锁库存
        stockService.lockStock(order.getStockNum());
        Result.ok().data("orderId",order.);
    } 
    return Result.error();
}

public abstract class AbstractQueuedSynchronizer 
   extends AbstractOwnableSynchronizer
    implements java.io.Serializable {
    
    //静态内部类，会把线程封装成一个个node节点放入队列
    static final class Node {...}
    
    //双向队列的头节点
    private transient volatile Node head;

    //双向队列的位节点
    private transient volatile Node tail;

    //标志当前资源的状态
    private volatile int state;
    
    ..... //还有很多方法
}

static final class Node {
       /** Marker to indicate a node is waiting in shared mode */
       static final Node SHARED = new Node(); //共享
       /** Marker to indicate a node is waiting in exclusive mode */
       static final Node EXCLUSIVE = null; //独占

       //withStatus的4中状态
       static final int CANCELLED =  1;  //表明节点(线程) 被取消或者中断
       static final int SIGNAL    = -1;  //表明节点被阻塞，需要unpark，即解锁
       static final int CONDITION = -2;
       static final int PROPAGATE = -3;

       volatile int waitStatus;

       volatile Node prev;
   
       volatile Node next;

       volatile Thread thread;

       Node nextWaiter;

       final boolean isShared() {
           return nextWaiter == SHARED;
       }

       final Node predecessor() throws NullPointerException {
           Node p = prev;
           if (p == null)
               throw new NullPointerException();
           else
               return p;
       }

       Node() {    // Used to establish initial head or SHARED marker
       }

       Node(Thread thread, Node mode) {     // Used by addWaiter
           this.nextWaiter = mode;
           this.thread = thread;
       }

       Node(Thread thread, int waitStatus) { // Used by Condition
           this.waitStatus = waitStatus;
           this.thread = thread;
       }
   }

@Autowired
private StringRedisTemplate redisTemplate;

@GetMapping("/buy")
public String buySales() {
//从redis中获取商品的数量
        String result = redisTemplate.opsForValue().get("goods:01");
        int nums = (result == null) ? 0 : Integer.parseInt(result);

        if (nums > 0) {
            //如果还有，商品数量-1
            int currentNums = nums - 1;
            redisTemplate.opsForValue().set("goods:01", String.valueOf(currentNums));
            System.out.println("成功买到商品，还剩余 " + currentNums + " 件");
            return "成功买到商品， 还剩 " + currentNums + "件";
        } else {
            System.out.println("购买失败、、、、");
        }
        return  "购买商品失败，因为xxxx原因......";
}

@GetMapping("/buy")
    public String buySales() {
        synchronized (this) {
            //从redis中获取商品的数量
            String result = redisTemplate.opsForValue().get("goods:01");
            int nums = (result == null) ? 0 : Integer.parseInt(result);

            if (nums > 0) {
                //如果还有，商品数量-1
                int currentNums = nums - 1;
                redisTemplate.opsForValue().set("goods:01", String.valueOf(currentNums));
                System.out.println("成功买到商品，还剩余 " + currentNums + " 件");
                return "成功买到商品， 还剩 " + currentNums + "件";
            } else {
                System.out.println("购买失败、、、、");
            }
            return  "购买商品失败，因为xxxx原因......";
        }
    }

/**
 * The root interface for accessing a Spring bean container.
 */
public interface BeanFactory {
    
}