J~杰's Blog

package com.fly.learn.executor;

import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

import java.util.concurrent.Executor;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;

/**
 * 线程池test
 * @author: peijiepang
 * @date 2018/11/23
 * @Description:
 */
public class ThreadPoolExecutorTest {
    private final static Logger LOGGER = LoggerFactory.getLogger(ThreadPoolExecutorTest.class);
    //private static ThreadPoolExecutor executor = new ThreadPoolExecutor(5, 10, 30, TimeUnit.SECONDS, new ArrayBlockingQueue<Runnable>(10));
    //private static Executor executor = Executors.newFixedThreadPool(5);
    //private static Executor executor = Executors.newSingleThreadExecutor();
    //private static Executor executor = Executors.newCachedThreadPool();
    private static ExecutorService executor = Executors.newScheduledThreadPool(5);

    public void executeTask(){
        Task1 task1 = new Task1();//构建任务
        executor.execute(task1);//执行任务
    }

    /*
     * 基本任务2
     */
    class Task1 implements Runnable{
        public void run() {
            //具体任务的业务
            for(int i=0;i<1000;i++){
                LOGGER.info("{}...",i);
            }
        }
    }
    public static void main(String[] args) {
        ThreadPoolExecutorTest test = new ThreadPoolExecutorTest();
        test.executeTask();
        executor.shutdown();
        while (!executor.isTerminated()){
            LOGGER.info("finish......");
        }
    }
}

package com.fly.learn.reentrantlock;

import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.Semaphore;

/**
 * @author: peijiepang
 * @date 2018/11/17
 * @Description:
 */
public class SemaphoreTest extends Thread{

    private final static Logger LOGGER = LoggerFactory.getLogger(SemaphoreTest.class);

    private Semaphore semaphore;


    public SemaphoreTest(String threadName,Semaphore semaphore) {
        this.semaphore = semaphore;
        this.setName(threadName);
    }

    @Override
    public void run(){
        try {
            semaphore.acquire();
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        try {
            Thread.sleep(1000l);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        LOGGER.info("{}......",Thread.currentThread().getName());
        semaphore.release();
    }

    public static void main(String[] args) {
        //公平锁
        Semaphore semaphore = new Semaphore(2,true);
        ExecutorService executorService = Executors.newFixedThreadPool(10);
        for (int i=0;i<10;i++){
            executorService.submit(new SemaphoreTest("thread_"+1,semaphore));
        }
        executorService.shutdown();
        LOGGER.info("finish.......");
    }
}

2018-11-17 21:05:46.644 [pool-2-thread-1] INFO  c.f.l.reentrantlock.SemaphoreTest - pool-2-thread-1......
2018-11-17 21:05:46.645 [pool-2-thread-2] INFO  c.f.l.reentrantlock.SemaphoreTest - pool-2-thread-2......
2018-11-17 21:05:47.647 [pool-2-thread-4] INFO  c.f.l.reentrantlock.SemaphoreTest - pool-2-thread-4......
2018-11-17 21:05:47.647 [pool-2-thread-3] INFO  c.f.l.reentrantlock.SemaphoreTest - pool-2-thread-3......
2018-11-17 21:05:48.650 [pool-2-thread-6] INFO  c.f.l.reentrantlock.SemaphoreTest - pool-2-thread-6......
2018-11-17 21:05:48.650 [pool-2-thread-5] INFO  c.f.l.reentrantlock.SemaphoreTest - pool-2-thread-5......
2018-11-17 21:05:49.652 [pool-2-thread-7] INFO  c.f.l.reentrantlock.SemaphoreTest - pool-2-thread-7......
2018-11-17 21:05:49.652 [pool-2-thread-8] INFO  c.f.l.reentrantlock.SemaphoreTest - pool-2-thread-8......
2018-11-17 21:05:50.657 [pool-2-thread-9] INFO  c.f.l.reentrantlock.SemaphoreTest - pool-2-thread-9......
2018-11-17 21:05:50.658 [pool-2-thread-10] INFO  c.f.l.reentrantlock.SemaphoreTest - pool-2-thread-10......

package com.fly.learn.reentrantlock;

import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

import java.util.concurrent.BrokenBarrierException;
import java.util.concurrent.CyclicBarrier;

/**
 * @author: peijiepang
 * @date 2018/11/14
 * @Description:
 */
public class CyclicBarrierTest {
    private final static Logger LOGGER = LoggerFactory.getLogger(CyclicBarrierTest.class);

    public static void main(String[] args) throws BrokenBarrierException, InterruptedException {
        CyclicBarrier cb = new CyclicBarrier(3, new Thread("barrierAction") {
            public void run() {
                LOGGER.info(Thread.currentThread().getName() + " barrier action");
            }
        });
        MyThread t1 = new MyThread("t1", cb);
        MyThread t2 = new MyThread("t2", cb);
        t1.start();
        t2.start();
        LOGGER.info(Thread.currentThread().getName() + " going to await");
        cb.await();
        LOGGER.info(Thread.currentThread().getName() + " continue");
    }

}

class MyThread extends Thread {
    private final static Logger LOGGER = LoggerFactory.getLogger(MyThread.class);

    private CyclicBarrier cb;
    public MyThread(String name, CyclicBarrier cb) {
        super(name);
        this.cb = cb;
    }

    public void run() {
        LOGGER.info(Thread.currentThread().getName() + " going to await");
        try {
            cb.await();
            LOGGER.info(Thread.currentThread().getName() + " continue");
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}

2018-11-14 23:14:23.641 [main] INFO  c.f.l.r.CyclicBarrierTest - main going to await
2018-11-14 23:14:23.641 [t2] INFO  com.fly.learn.reentrantlock.MyThread - t2 going to await
2018-11-14 23:14:23.640 [t1] INFO  com.fly.learn.reentrantlock.MyThread - t1 going to await
2018-11-14 23:14:23.648 [t1] INFO  c.f.l.r.CyclicBarrierTest - t1 barrier action
2018-11-14 23:14:23.648 [t1] INFO  com.fly.learn.reentrantlock.MyThread - t1 continue
2018-11-14 23:14:23.649 [t2] INFO  com.fly.learn.reentrantlock.MyThread - t2 continue
2018-11-14 23:14:23.650 [main] INFO  c.f.l.r.CyclicBarrierTest - main continue