Java 多线程和并发编程（续）

// 创建可变线程池

private ThreadPoolExecutor executor = (ThreadPoolExecutor)Executors.newCachedThreadPool();

// 创建固定线程池

private ThreadPoolExecutor executor = (ThreadPoolExecutor)Executors.newFixedThreadPool(5);

// 关闭线程池

executor.shutdown();

// 执行任务，无返回值

executor.execute(task);

// 执行任务，有返回值

Future<Integer> result=executor.submit(task);

/*

public class Task implements Callable<Integer> {

    @Override

    public Integer call() throws Exception {

        return null;

    }

}

*/

// 线程池基础信息

System.out.println(executor.getPoolSize());

System.out.println(executor.getActiveCount());

System.out.println(executor.getCompletedTaskCount());

//Future 返回类基本操作

result.isDone() // 判断任务是否完成

int sum=result.get(); // 获得结果

// 创建执行线程池

ForkJoinPool pool = new ForkJoinPool();

ForkJoinPool pool = new ForkJoinPool(4); // 固定线程池

// 创建任务

Task task = new Task(1, 10000000);

/*

public class Task extends RecursiveTask<Integer> {

    @Override

    protected Integer compute () {

        // 任务足够小，则直接执行

        //TODO

        // 任务大于阈值，分裂为 2 个任务

        invokeAll (subTask1,subTask2);

        Integer sum1 = subTask1.join ();

        Integer sum2 = subTask2.join ();

        // 结果合并

        sum = sum1 + sum2;

        return sum;

    }

}

*/

// 提交任务

ForkJoinTask<Integer> result = pool.submit(task);

// 输出结果

System.out.println(result.get().toString());

// 构造锁

private static final ReentrantLock queueLock = new ReentrantLock(); // 可重入锁

private static final ReentrantReadWriteLock orderLock = new ReentrantReadWriteLock(); // 可重入读写锁

// 基本函数

queueLock.tryLock()// 尝试加锁 (包含 lock)，返回 boolean

queueLock.lock() // 加锁

queueLock.unlock()// 解锁

orderLock.writeLock().lock()/unlock() // 写加锁 / 解锁 (写锁只能一个线程拥有)

orderLock.readLock().lock()/unlock() // 读加锁 / 解锁 (读锁多个线程共享)

// 构造信号量

private final Semaphore placeSemaphore = new Semaphore(5);

// 获取（信号量 - 1）

placeSemaphore.acquire();

// 尝试获取（包含 acquire）

placeSemaphore.tryAcquire()

// 释放（信号量 + 1）

placeSemaphore.release();

// 构造等待锁

CountDownLatch startSignal = new CountDownLatch(1);

// 计数减 1

startSignal.countDown();

// 等待 latch 变成 0

startSignal.await();

// 当有 3 个线程在 barrier 上 await，就执行 finalResultCalculator 中的 run 方法

CalculateFinalResult finalResultCalculator = new CalculateFinalResult(results);

CyclicBarrier barrier = new CyclicBarrier(3, finalResultCalculator);

//class CalculateFinalResult implements Runnable {}

// 等待

barrier.await();

// 构造

Phaser phaser = new Phaser(5);

// 等到 5 个线程都到了，才放行

phaser.arriveAndAwaitAdvance();

// 构造，交换类型为 String

Exchanger<String> exchanger = new Exchanger<String>();

// 对外交换 null, 获得内容放入 item 中

String item = exchanger.exchange(null);

/*

class Task extends TimerTask {

    public void run() {

        //TODO

    }

}

*/

// 当前时间 1 秒后，每 2 秒执行一次

timer.schedule(task, 1000, 2000);

// 取消当前的任务

task.cancel();

// 取消定时器

timer.cancel();

// 固定时间（1s 后）启动

ScheduledExecutorService executor = Executors.newScheduledThreadPool(1);

executor.schedule(new MyTask(),1,TimeUnit.SECONDS);

// 周期任务 固定速率 是以上一个任务开始的时间计时，period 时间过去后，检测上一个任务是否执行完毕

// 如果上一个任务执行完毕，则当前任务立即执行，如果上一个任务没有执行完毕，则需要等上一个任务执行完毕后立即执行

ScheduledExecutorService executor = Executors.newScheduledThreadPool(1);

executor.scheduleAtFixedRate(new MyTask(),1,3000,TimeUnit.MILLISECONDS);

// 周期任务 固定延时 是以上一个任务结束时开始计时，period 时间过去后，立即执行

ScheduledExecutorService executor = Executors.newScheduledThreadPool(1);

executor.scheduleWithFixedDelay(new MyTask(),1,3000,TimeUnit.MILLISECONDS);

import org.quartz.JobDetail;

import org.quartz.Scheduler;

import org.quartz.Trigger;

import org.quartz.impl.StdSchedulerFactory;

import static org.quartz.JobBuilder.newJob;

import static org.quartz.SimpleScheduleBuilder.simpleSchedule;

import static org.quartz.TriggerBuilder.newTrigger;

// 创建 scheduler

Scheduler scheduler = StdSchedulerFactory.getDefaultScheduler();

// 定义一个 Trigger

Trigger trigger = newTrigger().withIdentity("trigger1", "group1") // 定义 name/group

        .startNow()// 一旦加入 scheduler，立即生效

        .withSchedule(simpleSchedule() // 使用 SimpleTrigger

                .withIntervalInSeconds(2) // 每隔 2 秒执行一次

                .repeatForever()) // 一直执行

        .build();

// 定义一个 JobDetail

JobDetail job = newJob(HelloJob.class) // 定义 Job 类为 HelloQuartz 类

        .withIdentity("job1", "group1") // 定义 name/group

        .usingJobData("name", "quartz") // 定义属性

        .build();

/*

public class HelloJob implements Job {

    @Override

    public void execute(JobExecutionContext context) throws JobExecutionException {

        //TODO

    }

}

*/

// 加入这个调度

scheduler.scheduleJob(job, trigger);

// 启动

scheduler.start();

// 运行一段时间后关闭

Thread.sleep(10000);

scheduler.shutdown(true);