线程学习笔记-只是简单的应用

 原文：https://www.cnblogs.com/riskyer/p/3263032.html
 推荐文章：https://blog.51cto.com/lavasoft/27069
 1 /**
 * 线程同步 synchronized 的使用方法 问题：俩个线程调用同一个方法，要通过同步关键字实现 锁。使的方法结果正确
 *
 * 预期结果： 
 * test-1 :当前foo对象的x值= 70 test-1 :当前foo对象的x值= 40 test-1 :当前foo对象的x值= 10
 * test-2 :当前foo对象的x值= -20 test-2 :当前foo对象的x值= -50 test-2 :当前foo对象的x值= -80
 * 
 */
public class ThreadSynchronized {
    public static class Foo {
        private int x = 100;

        public int getX() {
            return x;
        }

        public int fix(int y) {
            x = x - y;
            return x;
        }

    }

    public static void main(String[] args) {

        Runnable r = new Runnable() {
            private Foo foo = new Foo();

            @Override
            public void run() {
                //原理就是给对象上锁，有钥匙的线程才能执行方法，保证一次只会进入一个线程
                synchronized (foo) {
                    for (int i = 0; i < 3; i++) {
                        foo.fix(30);
                        System.out.println(Thread.currentThread().getName() + " :当前foo对象的x值= " + foo.getX());
                    }
                }
            }
        };

        //这个是给线程起名字，线程默认也会给自己取名字的
        Thread a = new Thread(r, "test-1");
        Thread b = new Thread(r, "test-2");
        a.start();
        b.start();

    }
}

 

import java.util.concurrent.Callable;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.Future;


/**
 * 为什么要使用线程池？ 为了减少创建和销毁线程的次数，让每个线程可以多次使用,可根据系统情况调整执行的线程数量，防止消耗过多内存,所以我们可以使用线程池.
 * 
 * java中线程池的顶级接口是Executor(e可rai kei
 * ter)，ExecutorService是Executor的子类，也是真正的线程池接口，它提供了提交任务和关闭线程池等方法。调用submit方法提交任务还可以返回一个Future(fei
 * 曲儿)对象，利用该对象可以了解任务执行情况，获得任务的执行结果或取消任务。
 * 
 * 由于线程池的配置比较复杂，JavaSE中定义了Executors类就是用来方便创建各种常用线程池的工具类。通过调用该工具类中的方法我们可以创建单线程池(newSingleThreadExecutor),固定数量的线程池(newFixedThreadPool)，可缓存线程池(newCachedThreadPool),大小无限制的线程池(newScheduledThreadPool),比较常用的是固定数量的线程池和可缓存的线程池,固定数量的线程池是每提交一个任务就是一个线程，直到达到线程池的最大数量，然后后面进入等待队列直到前面的任务完成才继续执行.可缓存线程池是当线程池大小超过了处理任务所需的线程，那么就会回收部分空闲（一般是60秒无执行）的线程，当有任务来时，又智能的添加新线程来执行.
 * 
 * 
 * 
 * Executors类中还定义了几个线程池重要的参数,比如说int corePoolSize核心池的大小,也就是线程池中会维持不被释放的线程数量.int
 * maximumPoolSize线程池的最大线程数，代表这线程池汇总能创建多少线程。corePoolSize
 * :核心线程数，如果运行的线程数少corePoolSize，当有新的任务过来时会创建新的线程来执行这个任务，即使线程池中有其他的空闲的线程。maximumPoolSize:线程池中允许的最大线程数.
 *
 */
public class ThreadPool {

    
    public static void main(String[] args) throws InterruptedException, ExecutionException {

        Thread t1 = new Thread(() -> {
            System.out.println(Thread.currentThread().getName() + " t1");
        });

        Thread t2 = new Thread(() -> {
            System.out.println(Thread.currentThread().getName() + " t2");
        });

        Thread t3 = new Thread(() -> {
            System.out.println(Thread.currentThread().getName() + " t3");
        });

        /**
         * 固定线程池：newFixedThreadPool
         * 
         * 当线程池大小为小于线程个数 
         * pool-1-thread-1 t1 
         * pool-1-thread-1 t2 
         * pool-1-thread-1 t3
         * 
         * 当线程池大小大于等于线程个数
         * 
         * pool-1-thread-2 t2 
         * pool-1-thread-3 t3 
         * pool-1-thread-1 t1
         * 
         * 对于以上两种连接池，大小都是固定的，当要加入的池的线程（或者任务）超过池最大尺寸时候，则入此线程池需要排队等待。
         * 一旦池中有线程完毕，则排队等待的某个线程会入池执行。
         * 
         */
//        ExecutorService pool = Executors.newFixedThreadPool(10);
//        pool.execute(t1);
//        pool.execute(t2);
//        pool.execute(t3);
//        pool.shutdown();
        
        /**
         * 单任务线程池：newSingleThreadExecutor
         * 结果：
         * pool-1-thread-1 t1
         * pool-1-thread-1 t2
         * pool-1-thread-1 t3
         */
//        ExecutorService pool = Executors.newSingleThreadExecutor();
//        pool.execute(t1);
//        pool.execute(t2);
//        pool.execute(t3);
//        pool.shutdown();
        
        /**
         * 以上俩种都是固定大小的线程池
         * 现在说一下可变大小的线程池：
         * newCachedThreadPool:根据需要创建线程池
         * pool-1-thread-1 t1
         * pool-1-thread-3 t3
         * pool-1-thread-2 t2
         */
//        ExecutorService pool = Executors.newCachedThreadPool();
//        pool.execute(t1);
//        pool.execute(t2);
//        pool.execute(t3);
//        pool.shutdown();
        
        /**
         * newScheduledThreadPool:延迟连接池
         * pool-1-thread-1 t1
           * pool-1-thread-2 t2
          * pool-1-thread-1 t3
         * pool-1-thread-2 t1
         * pool-1-thread-1 t2
         * pool-1-thread-2 t3
         */
//        ScheduledExecutorService pool = Executors.newScheduledThreadPool(2);
        //放入线程池中执行
//        pool.execute(t1);
//        pool.execute(t2);
//        pool.execute(t3);
        //使用延迟执行
//        pool.schedule(t1, 10, TimeUnit.SECONDS);
//        pool.schedule(t2, 10, TimeUnit.SECONDS);
//        pool.schedule(t3, 10, TimeUnit.SECONDS);
//        pool.shutdown();
        
        /**
         * newSingleThreadScheduledExecutor:单任务延迟线程池
         * pool-1-thread-1 t1
         * pool-1-thread-1 t2
         * pool-1-thread-1 t3
         * pool-1-thread-1 t1
         * pool-1-thread-1 t2
         * pool-1-thread-1 t3
         */
//        ScheduledExecutorService pool = Executors.newSingleThreadScheduledExecutor();
//        //放入线程池中执行
//        pool.execute(t1);
//        pool.execute(t2);
//        pool.execute(t3);
//        //使用延迟执行
//        pool.schedule(t1, 10, TimeUnit.SECONDS);
//        pool.schedule(t2, 10, TimeUnit.SECONDS);
//        pool.schedule(t3, 10, TimeUnit.SECONDS);
//        pool.shutdown();
        
        /**
         * ThreadPoolExecutor:自定义线程池
         */
//        BlockingQueue<Runnable> bQueue = new ArrayBlockingQueue<>(20);
//        ThreadPoolExecutor pool = new ThreadPoolExecutor(1,3 , 10, TimeUnit.MILLISECONDS, bQueue);
//        pool.execute(t1);
//        pool.execute(t2);
//        pool.execute(t3);
//        pool.shutdown();
        /**
         * 在这多说一句：自定义线程池涉及到拒绝策略
         * 当线程池的任务缓存队列已满并且线程池中的线程数目达到maximumPoolSize时，
         * 如果还有任务到来就会采取任务拒绝策略，通常有以下四种策略：
         * ThreadPoolExecutor.AbortPolicy:丢弃任务并抛出
         * RejectedExecutionException异常。 
         * ThreadPoolExecutor.DiscardPolicy：丢弃任务，但是不抛出异常。 
         * ThreadPoolExecutor.DiscardOldestPolicy：丢弃队列最前面的任务，然后重新提交被拒绝的任务 
         * ThreadPoolExecutor.CallerRunsPolicy：由调用线程（提交任务的线程）处理该任务 
         * 
         * （1）AbortPolicy
         * ThreadPoolExecutor.AbortPolicy:丢弃任务并抛出RejectedExecutionException异常。
         * A handler for rejected tasks that throws a {@code RejectedExecutionException}.
         * 这是线程池默认的拒绝策略，在任务不能再提交的时候，抛出异常，及时反馈程序运行状态。如果是比较关键的业务，推荐使用此拒绝策略，这样子在系统不能承载更大的并发量的时候，能够及时的通过异常发现。
         * （2）DiscardPolicy
         * ThreadPoolExecutor.DiscardPolicy：丢弃任务，但是不抛出异常。如果线程队列已满，则后续提交的任务都会被丢弃，且是静默丢弃。
         * A handler for rejected tasks that silently discards therejected task.
         * 使用此策略，可能会使我们无法发现系统的异常状态。建议是一些无关紧要的业务采用此策略。例如，本人的博客网站统计阅读量就是采用的这种拒绝策略。
         * （3）DiscardOldestPolicy
         * ThreadPoolExecutor.DiscardOldestPolicy：丢弃队列最前面的任务，然后重新提交被拒绝的任务。
         * A handler for rejected tasks that discards the oldest unhandled request and then retries {@code execute}, unless the executor is shut down, in which case the task is discarded.
         * 此拒绝策略，是一种喜新厌旧的拒绝策略。是否要采用此种拒绝策略，还得根据实际业务是否允许丢弃老任务来认真衡量。
         * （4）CallerRunsPolicy
         * ThreadPoolExecutor.CallerRunsPolicy：由调用线程处理该任务
         * A handler for rejected tasks that runs the rejected task directly in the calling thread of the {@code execute} method, unless the executor has been shut down, in which case the task is discarded.
         * 如果任务被拒绝了，则由调用线程（提交任务的线程）直接执行此任务
         */
        
        /*
         * 获取线程的返回值：需要实现
         * 结果：A
         */
        Callable callable = new Callable<Object>() {
            @Override
            public Object call() throws Exception {
                return "A";
            }
        };
        ExecutorService pool = Executors.newFixedThreadPool(2); 
        Future f4 = pool.submit(callable);  
        //这个获取值有一个执行线程顺序的坑，在异步的时候会出现，记不清啦
        System.out.println(f4.get().toString());
    }
}

 

import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;

/**
 * 在Java5中，专门提供了锁对象，利用锁可以方便的实现资源的封锁，用来控制对竞争资源并发访问的控制，这些内容主要集中在java.util.concurrent.locks包下面，里面有三个重要的接口Condition、Lock、ReadWriteLock。
 * 
 * 
 * 
 * Condition
 * 
 * Condition将Object监视器方法（wait、notify和
 * notifyAll）分解成截然不同的对象，以便通过将这些对象与任意Lock实现组合使用，为每个对象提供多个等待 set（wait-set）。
 * 
 * Lock
 * 
 * Lock实现提供了比使用synchronized方法和语句可获得的更广泛的锁定操作。
 * 
 * ReadWriteLock
 * 
 * ReadWriteLock维护了一对相关的锁定，一个用于只读操作，另一个用于写入操作。
 *
 * 
 * 切記：锁是针对对象的
 */
public class ThreadLock {

    /**
     * 信用卡的用户
     */
    static class User implements Runnable {
        private String name; // 用户名
        private MyCount myCount; // 所要操作的账户
        private int iocash; // 操作的金额，当然有正负之分了
        private Lock myLock; // 执行操作所需的锁对象

        User(String name, MyCount myCount, int iocash, Lock myLock) {
            this.name = name;
            this.myCount = myCount;
            this.iocash = iocash;
            this.myLock = myLock;
        }

        public void run() {
            // ’获取锁
            myLock.lock();
            myCount.setCash(myCount.getCash() + iocash);
            // ’执行现金业务
            System.out.println(name + "正在操作" + myCount + "账户，金额为" + iocash + "，当前金额为" + myCount.getCash());
            // ‘释放锁，否则别的线程没有机会执行了
            myLock.unlock();
        }
    }

    /**
     * 信用卡账户，可随意透支
     */
    static class MyCount {
        private String oid; // 账号
        private int cash; // 账户余额

        MyCount(String oid, int cash) {
            this.oid = oid;
            this.cash = cash;
        }

        public String getOid() {
            return oid;
        }

        public void setOid(String oid) {
            this.oid = oid;
        }

        public int getCash() {
            return cash;
        }

        public void setCash(int cash) {
            this.cash = cash;
        }

        @Override
        public String toString() {
            return "MyCount{" + "oid='" + oid + '\'' + ", cash=" + cash + '}';
        }
    }

    public static void main(String[] args) {
        // ’创建并发访问的账户
        MyCount myCount = new MyCount("95599200901215522", 10000);
        // ‘创建一个锁对象
        Lock lock = new ReentrantLock();
        // ‘创建一个线程池
        ExecutorService pool = Executors.newCachedThreadPool();
        //’创建一些并发访问用户，一个信用卡，存的存，取的取，好热闹啊
        User u1 = new User("张三", myCount, -4000, lock);
        User u2 = new User("张三他爹", myCount, 6000, lock);
        User u3 = new User("张三他弟", myCount, -8000, lock);
        User u4 = new User("张三", myCount, 800, lock);
        // ’在线程池中执行各个用户的操作
        pool.execute(u1);
        pool.execute(u2);
        pool.execute(u3);
        pool.execute(u4);
        // ‘关闭线程池
        pool.shutdown();
    }
}

 

import java.util.concurrent.ArrayBlockingQueue;
import java.util.concurrent.BlockingQueue;

/*
 * 阻塞队列是Java5线程新特征中的内容，Java定义了阻塞队列的接口java.util.concurrent.BlockingQueue，阻塞队列的概念是，一个指定长度的队列，如果队列满了，添加新元素的操作会被阻塞等待，直到有空位为止。同样，当队列为空时候，请求队列元素的操作同样会阻塞等待，直到有可用元素为止。

 

有了这样的功能，就为多线程的排队等候的模型实现开辟了便捷通道，非常有用。

 

java.util.concurrent.BlockingQueue继承了java.util.Queue接口，可以参看API文档。

另外，阻塞队列还有更多实现类，用来满足各种复杂的需求：ArrayBlockingQueue, DelayQueue, LinkedBlockingQueue, PriorityBlockingQueue, SynchronousQueue，具体的API差别也很小。
 */
public class ThreadBlockingQueue {
    public static void main(String[] args) throws InterruptedException {
        BlockingQueue bqueue = new ArrayBlockingQueue<>(10);
        for (int i = 0; i < 20; i++) {
            bqueue.put(i);
            System.err.println(i);
        }
        //’可以看出，输出到元素9时候，就一直处于等待状态，因为队列满了，程序阻塞了。
        System.out.println("exit");
    }
}

 

import java.util.concurrent.BlockingDeque;
import java.util.concurrent.LinkedBlockingDeque;

/**
 * 对于阻塞栈，与阻塞队列相似。不同点在于栈是“后入先出”的结构，每次操作的是栈顶，而队列是“先进先出”的结构，每次操作的是队列头。
 * 
 * 
 * 
 * 这里要特别说明一点的是，阻塞栈是Java6的新特征。、
 * 
 * 
 * 
 * Java为阻塞栈定义了接口：java.util.concurrent.BlockingDeque，其实现类也比较多，具体可以查看JavaAPI文档。
 * 
 * 从上面结果可以看到，程序并没结束，二是阻塞住了，原因是栈已经满了，后面追加元素的操作都被阻塞了。
 */
public class ThreadBlockingDeque {

    public static void main(String[] args) throws InterruptedException {
        BlockingDeque bDeque = new LinkedBlockingDeque<>(10);
        for (int i = 0; i < 20; i++) {
            bDeque.putFirst(i);
            System.err.println(i);
        }
        System.out.println("exit");
    }
}

 

import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.locks.Condition;
import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;

/**
 * 条件变量是Java5线程中很重要的一个概念，顾名思义，条件变量就是表示条件的一种变量。但是必须说明，这里的条件是没有实际含义的，仅仅是个标记而已，并且条件的含义往往通过代码来赋予其含义。
 * 
 * 
 * 
 * 这里的条件和普通意义上的条件表达式有着天壤之别。
 * 
 * 
 * 
 * 条件变量都实现了java.util.concurrent.locks.Condition接口，条件变量的实例化是通过一个Lock对象上调用newCondition()方法来获取的，这样，条件就和一个锁对象绑定起来了。因此，Java中的条件变量只能和锁配合使用，来控制并发程序访问竞争资源的安全。
 * 
 * 
 * 
 * 条件变量的出现是为了更精细控制线程等待与唤醒，在Java5之前，线程的等待与唤醒依靠的是Object对象的wait()和notify()/notifyAll()方法，这样的处理不够精细。
 * 
 * 
 * 
 * 而在Java5中，一个锁可以有多个条件，每个条件上可以有多个线程等待，通过调用await()方法，可以让线程在该条件下等待。当调用signalAll()方法，又可以唤醒该条件下的等待的线程。有关Condition接口的API可以具体参考JavaAPI文档。
 * 
 * 
 * 
 * 条件变量比较抽象，原因是他不是自然语言中的条件概念，而是程序控制的一种手段。
 * 
 * 
 * 
 * 下面以一个银行存取款的模拟程序为例来揭盖Java多线程条件变量的神秘面纱：
 * 
 * 
 * 
 * 有一个账户，多个用户（线程）在同时操作这个账户，有的存款有的取款，存款随便存，取款有限制，不能透支，任何试图透支的操作都将等待里面有足够存款才执行操作。
 *
 */
public class ThreadCondition {
    static class MyAccount {
        private String oid;
        private int cash;
        private Lock lock = new ReentrantLock();
        private Condition _save = lock.newCondition();
        private Condition _draw = lock.newCondition();

        public String getOid() {
            return oid;
        }

        public void setOid(String oid) {
            this.oid = oid;
        }

        public int getCash() {
            return cash;
        }

        public void setCash(int cash) {
            this.cash = cash;
        }

        public MyAccount(String oid, int cash) {
            super();
            this.oid = oid;
            this.cash = cash;
        }

        public void saving(int x, String name) {
            lock.lock();
            setCash(cash + x);
            System.out.println(Thread.currentThread().getName() + " name " + name + "x " + x + " ,cash " + cash);
            _draw.signalAll();
            lock.unlock();
        }

        public void drawing(int x, String name) {
            lock.lock();
            try {
                while (cash - x < 0) {
                    _draw.await();
                    _save.signalAll();
                }
                setCash(cash - x);
                System.out.println(Thread.currentThread().getName() + " name " + name + "x " + x + " ,cash " + cash);
            } catch (InterruptedException e) {
                // TODO Auto-generated catch block
                e.printStackTrace();
            } finally {
                lock.unlock();
            }

        }

    }

    static class SaveThread extends Thread {
        private String name;
        private MyAccount myAccount;
        private int x;

        public SaveThread(String name, MyAccount myAccount, int x) {
            super();
            this.name = name;
            this.myAccount = myAccount;
            this.x = x;
        }

        @Override
        public void run() {
            myAccount.saving(x, name);
        }

    }

    static class DrawThread extends Thread {
        private String name;
        private MyAccount myAccount;
        private int x;

        public DrawThread(String name, MyAccount myAccount, int x) {
            super();
            this.name = name;
            this.myAccount = myAccount;
            this.x = x;
        }

        @Override
        public void run() {
            myAccount.drawing(x, name);
        }
    }

    public static void main(String[] args) {
        // ‘创建并发访问的账户
        MyAccount myAccount = new MyAccount("95599200901215522", 10000);
        // ’ 创建一个线程池
        ExecutorService pool = Executors.newFixedThreadPool(12);
        Thread t1 = new SaveThread("张三", myAccount, 2000);
        Thread t2 = new SaveThread("李四", myAccount, 3600);
        Thread t3 = new DrawThread("王五", myAccount, 2700);
        Thread t4 = new SaveThread("老张", myAccount, 600);
        Thread t5 = new DrawThread("老牛", myAccount, 1300);
        Thread t6 = new DrawThread("胖子", myAccount, 800);
        // ‘ 执行各个线程
        pool.execute(t1);
        pool.execute(t2);
        pool.execute(t3);
        pool.execute(t4);
        pool.execute(t5);
        pool.execute(t6);
        // ’ 关闭线程池
        pool.shutdown();
    }
}

 

import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.atomic.AtomicLong;
import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;

/**
 * 
 * Java线程：新特征-原子量 所谓的原子量即操作变量的操作是“原子的”，该操作不可再分，因此是线程安全的。
 * 
 * 
 * 
 * 为何要使用原子变量呢，原因是多个线程对单个变量操作也会引起一些问题。在Java5之前，可以通过volatile、synchronized关键字来解决并发访问的安全问题，但这样太麻烦。
 * 
 * Java5之后，专门提供了用来进行单变量多线程并发安全访问的工具包java.util.concurrent.atomic，其中的类也很简单。
 * 
 * 这里使用了一个对象锁，来控制对并发代码的访问。不管运行多少次，执行次序如何，最终余额均为21000，这个结果是正确的。
 * 
 * 
 * 
 * 有关原子量的用法很简单，关键是对原子量的认识，原子仅仅是保证变量操作的原子性，但整个程序还需要考虑线程安全的。
 */
public class ThreadAtomic {

    static class MyRunnable implements Runnable {
        private AtomicLong atomicLong = new AtomicLong(10000);

        private String name; // 操作人
        private int x; // 操作数额
        private Lock lock = new ReentrantLock();

        public String getName() {
            return name;
        }

        public void setName(String name) {
            this.name = name;
        }

        public int getX() {
            return x;
        }

        public void setX(int x) {
            this.x = x;
        }

        public MyRunnable(String name, int x) {
            super();
            this.name = name;
            this.x = x;
        }

        @Override
        public void run() {
            lock.lock();
            System.out.println(Thread.currentThread().getName() + " name: " + name + " x " + x + " 执行啦 "
                    + atomicLong.addAndGet(x));
            lock.unlock();
        }

    }

    public static void main(String[] args) {
        ExecutorService pool = Executors.newFixedThreadPool(2);
//           Lock lock = new ReentrantLock(false);
        Runnable t1 = new MyRunnable("张三", 2000);
        Runnable t2 = new MyRunnable("李四", 3600);
        Runnable t3 = new MyRunnable("王五", 2700);
        Runnable t4 = new MyRunnable("老张", 600);
        Runnable t5 = new MyRunnable("老牛", 1300);
        Runnable t6 = new MyRunnable("胖子", 800);
        // 执行各个线程
        pool.execute(t1);
        pool.execute(t2);
        pool.execute(t3);
        pool.execute(t4);
        pool.execute(t5);
        pool.execute(t6);
        // 关闭线程池
        pool.shutdown();

    }
}

 

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

/**
 * java5中，添加了障碍器类，为了适应一种新的设计需求，比如一个大型的任务，常常需要分配好多子任务去执行，只有当所有子任务都执行完成时候，才能执行主任务，这时候，就可以选择障碍器了。
 * 所有子任务完成的时候，主任务执行了，达到了控制的目标。
 */
public class ThreadCyclicBarrier {
    static class MainTask implements Runnable {

        @Override
        public void run() {
            System.out.println("mainTask");
        }

    }

    static class SubTask extends Thread {
        private CyclicBarrier cb;
        private String name;

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

        @Override
        public void run() {

            try {
                System.out.println(name);
                cb.await();
            } catch (InterruptedException e) {
                // TODO Auto-generated catch block
                e.printStackTrace();
            } catch (BrokenBarrierException e) {
                // TODO Auto-generated catch block
                e.printStackTrace();
            }
        }
    }

    public static void main(String[] args) {
        // 创建障碍器，并设置MainTask为所有定数量的线程都达到障碍点时候所要执行的任务(Runnable)
        CyclicBarrier cb = new CyclicBarrier(7, new MainTask());
        new SubTask("A", cb).start();
        new SubTask("B", cb).start();
        new SubTask("C", cb).start();
        new SubTask("D", cb).start();
        new SubTask("E", cb).start();
        new SubTask("F", cb).start();
        new SubTask("G", cb).start();
    }
}