黑马程序员-JAVA-多线程使用初探

——Java培训、Android培训、iOS培训、.Net培训、期待与您交流！ ——-

---

Java中建立线程的一般方法

Java中对于线程的操作依赖于类Thread，这个类是线程在Java中的抽象

Thread类的构造方法有3个要素和一个可选项，三个参数分别为String name，Runnable target和ThreadGroup group。另外可以指定long stackSize堆栈大小。

可以通过两种方法来建立线程：
1.继承Thread类，覆盖run()方法。
2.实现Runnable接口，实现run()方法，并传入Thread构造函数启动。一般来说，采用这种方式的情况比较多，因为继承的限制比较大。

如果一个Thread子类（比如常见的匿名类）用Runnable对象构造，那么运行取决于其run()是否调用Thread类中的run()，或是target.run()；如果不显式的super.run()或者target.run()那么传入的Runnable是无意义的
例子如下：

        // duplicate run()
        new Thread(new Runnable() {

            @Override
            public void run() {
                sp("anonymous runnable:" + this);
                try {
                    Thread.sleep(1000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        }) {
            @Override
            public void run() {
                while (true) {
                    sp("anonymous subclass:" + this.getName());
                    try {
                        Thread.sleep(1000);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }
            }
        }.start();//anonymous subclass:Thread-

Timer

Timer是一种工具，线程用其安排以后在后台线程中执行的任务。可安排任务执行一次，或者定期重复执行。每个 Timer 对象相对应的是单个后台线程，用于顺序地执行所有计时器任务。Timer的任务是由传入的schedule参数TimerTask。而且构造对象即是开始Timer线程。
也可以使用Timer嵌套创建Timer，下面是一个用TimerTask嵌套交替创建Timer执行的例子：

        // alternate timer shedule
        new Timer().schedule(new YTask(), 2000);

    static class YTask extends TimerTask {
        int nextSpan;

        public YTask(int i) {
            this.nextSpan = i == 2 ? 4 : 2;
        }

        public YTask() {
            this(2);
        }

        @Override
        public void run() {
            sp("bbbb");
            new Timer().schedule(new YTask(nextSpan), 1000 * nextSpan);
        }

    }

线程的安全问题与同步

非同步错误

多个线程访问同一个对象或者资源时，如果没有采取同步手段防止竞争很有可能造成非预期的结果，比如这个简单的例子：

        // unsynchonize problem
        new Thread(new UnsyncedOutput("shengguangzu")).start();
        new Thread(new UnsyncedOutput("liuzhijun")).start();

    static class UnsyncedOutput implements Runnable {
        String content;

        public UnsyncedOutput(String content) {
            super();
            this.content = content;
        }

        @Override
        public void run() {
            while (true) {
                try {
                    Thread.sleep(10);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                output();
            }
        }

        public void output() {
            // uncomment to fix
            // synchronized (System.out) {
                for (char c : content.toCharArray()) {
                    System.out.print(c);
                }
            // }
            System.out.println();
        }

    }

死锁

在使用同步锁机制时，如果没有仔细分析锁的竞争，在使用多个锁的时候可能造成死锁，即锁无法被正确的释放，相关线程都无法继续，进入阻塞状态。
一个简单的例子：

// dead lock
        Object lockA=new Object(),lockB=new Object();
        new Thread(new Runnable() {

            @Override
            public void run() {
                synchronized (lockB) {
                    sp(Thread.currentThread().getName()+"got lockB");
                    ts(100);
                    synchronized (lockA) {//can't got
                        sp(Thread.currentThread().getName()+"got lockA");//unreachable
                    }
                }
                sp(Thread.currentThread().getName()+" finish");//unreachable
            }
        }).start();
        new Thread(new Runnable() {

            @Override
            public void run() {
                synchronized (lockA) {
                    sp(Thread.currentThread().getName()+"got lockA");
                    ts(100);
                    synchronized (lockB) {//can't got
                        sp(Thread.currentThread().getName()+"got lockB");//unreachable
                    }
                }
                sp(Thread.currentThread().getName()+" finish");//unreachable
            }
        }).start();

wait和notify

依赖线程调度大部分情况可以较好的完成任务，但是在线程较多的时候会比较消耗资源，这时需要一种机制来使线程进入相对长时间的休眠，等到信号才唤醒继续。这就是wait和notify机制，下面是一个利用wait和notify机制交替执行线程的例子：

// wait & notify
        Business biz=new Business();
        new Thread(new Runnable() {

            @Override
            public void run() {
                // TODO Auto-generated method stub
                biz.doA();
            }
        }).start();
        new Thread(new Runnable() {

            @Override
            public void run() {
                // TODO Auto-generated method stub
                biz.doB();
            }
        }).start();
    static class Business{
        volatile int signal;

        public Business() {
            super();
            this.signal=1;
        }

        public void doA(){
            while(true){
                synchronized (this) {
                    while(signal!=1){
                        try {
                            this.wait();
                        } catch (InterruptedException e) {
                            e.printStackTrace();
                        }
                    }
                    sp("start A in "+Thread.currentThread().getName());
                    ts(new Random().nextInt(2000));
                    sp("done A in "+Thread.currentThread().getName());
                    this.signal=2;
                    this.notify();
                }
            }
        }
        public void doB(){
            while(true){
                synchronized (this) {
                    while(signal!=2){
                        try {
                            this.wait();
                        } catch (InterruptedException e) {
                            e.printStackTrace();
                        }
                    }
                    sp("start B in "+Thread.currentThread().getName());
                    ts(new Random().nextInt(2000));
                    sp("done B in "+Thread.currentThread().getName());
                    this.signal=1;
                    this.notify();
                }
            }
        }
    }

多线程中的单例

由于多个线程可能竞争使用一个单例，如果采用懒汉式，则有可能产生超过一个实例对象，这时就需要双重检查，即进入同步块后再检查一次。
下面是一些单例的实现模式，均为线程安全：

    // double check singleton
    static class SyncSingleton {
        //volatile to avoid exception
        private static volatile SyncSingleton instance;

        private SyncSingleton() {
        };

        public static SyncSingleton getInstance() {
            if (instance == null) {// check before lock
                synchronized (SyncSingleton.class) {
                    if (instance == null) {// check after lock
                        instance = new SyncSingleton();
                    }
                }
            }
            return instance;
        }
    }

    // another double check way
    // with prevent deserialize in Serializable
    static class SyncSingleton2 implements Serializable{
        /**
         * 
         */
        private static final long serialVersionUID = 4675690059690737395L;
        //volatile to avoid exception
        private volatile static SyncSingleton instance;

        private SyncSingleton2() {
        };

        //this way has an lower efficient
        public static synchronized SyncSingleton getInstance() {
            if (instance == null) {// check after lock
                instance = new SyncSingleton();
            }
            return instance;
        }

        //this method to prevent deserialize crack
        private Object readResolve() throws ObjectStreamException{
            return instance;
        }
    }

    //hungry way
    static class HungrySingleton{
        private static HungrySingleton instance=new HungrySingleton();
        private HungrySingleton(){};
        public static HungrySingleton getInstance(){
            return instance;
        }
    }

    // inner class way it's lazy
    static class InnerClassSingleton{
        private InnerClassSingleton(){};
        private static class SingletonHolder{
            private static InnerClassSingleton instance=new InnerClassSingleton();
        }
        public InnerClassSingleton getInstance(){
            return SingletonHolder.instance;
        }
    }

    // singleton by enum 
    // concurrent safe ,deserialize safe,and easy
    static enum EnumSingleton {
        INSTANCE;
        private EnumSingleton() {
        };// that's all we need
    }

线程范围的数据共享

有时我们需要在线程级别共享一个数据，一般的，可以使用一个静态HashMap，用线程做key，在使用处调用即可，也不需要同步锁。
但是Java已经提供了一个使用更方便的容器：
ThreadLocal
这个容器很简单，只有4个方法， T get() ，protected T initialValue() ， void remove() ， void set(T value) 。一目了然，在操作容器内对象的时候，ThreadLocal会自动查询当前线程上下文，对对应的对象进行操作。
简单的示例：

        // ThreadLocal demo
        final ThreadLocal<Integer> ti = new ThreadLocal<Integer>();
        for (int i = 0; i < 4; i++) {
            new Thread(new Runnable() {

                @Override
                public void run() {
                    int val = r.nextInt(10000);
                    ti.set(val);
                    sp("ThreadLocal val of " + Thread.currentThread().getName()
                            + " set to " + val);
                    ts(r.nextInt(3000));
                    sp("ThreadLocal val of " + Thread.currentThread().getName()
                            + " is " + ti.get());
                }
            }).start();
        }

Java1.5中关于线程的新特性

java.util.concurrent.atomic

类的小工具包，支持在单个变量上解除锁的线程安全编程。
一般来说，实现了在一个元素上的一次复合操作的原子性，即保证其修改符合预期。
已经支持的类型有Integer，Long，Boolean，还有Reference的引用类型。

线程池

Executor 定义了一个提交Runnable任务的执行器。而ExecutorService则定义了更为实用的可以提交Runnable任务或者Callable任务，并且可以关闭的执行器。
Java已经通过线程池实现了ExecutorService，而且提供了Executors的工厂方法来产生各种线程池执行器。

newCachedThreadPool()

建一个可根据需要创建新线程的线程池，但是在以前构造的线程可用时将重用它们。默认的存活时间是60秒。

newFixedThreadPool(int nThreads)

创建一个可重用固定线程数的线程池，以共享的无界队列方式来运行这些线程。在某个线程被显式地关闭之前，池中的线程将一直存在。

newSingleThreadExecutor()

创建一个使用单个 worker 线程的 Executor，以无界队列方式来运行该线程。注意，如果因为在关闭前的执行期间出现失败而终止了此单个线程，那么如果需要，一个新线程将代替它执行后续的任务。

Callable & Future

泛型返回的ExecutorService任务，其中Callable指定一个泛型返回类型，交给指定的ExecutorService执行之后，返回Future，在异步执行过程中，可以通过查询Future的isDone() 来了解完成状况。完成之后，可以通过Future的get() 来获取结果，如果get() 时尚未完成，则将阻塞。
Java中对此的默认实现是FutureTask

使用Future的线程池的简单例子

        // ThreadPool demo with Future
        ExecutorService exes = Executors.newFixedThreadPool(3);
        final int times = 20;
        final List<Future<Integer>> results = new ArrayList<Future<Integer>>(
                times);
        for (int i = 0; i < times; i++) {
            results.add(exes.submit(() -> {
                ts(1000);
                int nextInt = r.nextInt(1000);
                sp("gen num :" + nextInt + " in "
                        + Thread.currentThread().getName());
                return nextInt;
            }));
        }
        for (Future<Integer> future : results) {
            try {
                sp(future.get());
            } catch (InterruptedException | ExecutionException e) {
                e.printStackTrace();
            }
        }
        exes.shutdown();

java.util.concurrent.locks

Java1.5为锁和等待条件提供一个接口和类的框架，它相对内置的synchonized和wait/notify机制有所增强。

Lock

synchronized 方法或语句的使用提供了对与每个对象相关的隐式监视器锁的访问，但却强制所有锁获取和释放均要出现在一个块结构中：当获取了多个锁时，它们必须以相反的顺序释放，且必须在与所有锁被获取时相同的词法范围内释放所有锁。
而Lock提供了更为灵活的机制：它可以以任意顺序解锁，例如，某些遍历并发访问的数据结果的算法要求使用 “hand-over-hand” 或 “chain locking”：获取节点 A 的锁，然后再获取节点 B 的锁，然后释放 A 并获取 C，然后释放 B 并获取 D，依此类推。Lock 还实现提供了使用 synchronized 方法和语句所没有的其他功能，包括提供了一个非块结构的获取锁尝试 (tryLock())、一个获取可中断锁的尝试 (lockInterruptibly()) 和一个获取超时失效锁的尝试 (tryLock(long, TimeUnit))。
锁定和取消锁定出现在不同作用范围中时，必须谨慎地确保保持锁定时所执行的所有代码用 try-finally 或 try-catch 加以保护，以确保在必要时释放锁。
注意，Lock 实例只是普通的对象，其本身可以在 synchronized 语句中作为目标使用。为了避免混淆，建议除了在其自身的实现中之外，决不要以这种方式使用 Lock 实例。

一般的使用Lock的格式：

     Lock l = ...; 
     l.lock();
     try {
         // access the resource protected by this lock
     } finally {
         l.unlock();
     }

ReadWriteLock

ReadWriteLock实现了对同一资源的一对相关锁，其特殊之处在于没有写锁的情况下允许并发读锁，在读的发生频率较高的时候可以提高系统效率。而写锁依然是独占的。
一个简单的例子：读操作可以并发

        //ReadWriteLock
        ReadWriteLockDemo lockObj=new ReadWriteLockDemo();
        for (int i = 0; i < 4; i++) {
            if(i==3){
                new Thread(new Runnable() {
                    @Override
                    public void run() {
                        while(true){
                            lockObj.set(r.nextInt(1000));
                        }
                    }
                }).start();
            }
            new Thread(new Runnable() {
                @Override
                public void run() {
                    while(true){
                        lockObj.get();
                    }
                }
            }).start();
        }
    static class ReadWriteLockDemo{
        Object data;
        ReadWriteLock rwl=new ReentrantReadWriteLock();
        {
            data=123;
        }
        public void get(){
            rwl.readLock().lock();
            try {
                sp("prepare to read in"+Thread.currentThread().getName());
                ts(new Random().nextInt(300));
                sp("data is : "+data+" from "+Thread.currentThread().getName());
                ts(new Random().nextInt(100));
                sp("done to read in"+Thread.currentThread().getName());
            }finally{
                rwl.readLock().unlock();
            }
            ts(new Random().nextInt(1000));
        }
        public void set(Object o){
            rwl.writeLock().lock();
            try {
                sp("prepare to write in"+Thread.currentThread().getName());
                ts(new Random().nextInt(300));
                data=o;
                sp("data has set to : "+data+" from "+Thread.currentThread().getName());
                ts(new Random().nextInt(100));
                sp("done to write in"+Thread.currentThread().getName());
            }finally{
                rwl.writeLock().unlock();
            }
            ts(new Random().nextInt(1000));
        }
    }

Condition

Condition 实现了一个面向锁的线程控制等待和唤醒的条件机制，相较于wait&notify机制，它能对同一个锁添加多个Condition，以实现多重状态的判断。
这是一个利用Condition实现3个操作轮流执行的例子：

        // Condition
        final ConditionDemo cd=new ConditionDemo();
        new Thread(() -> cd.BusinessA()).start();
        new Thread(() -> cd.BusinessB()).start();
        new Thread(() -> cd.BusinessC()).start();
        new Thread(() -> cd.BusinessA()).start();
        new Thread(() -> cd.BusinessB()).start();
        new Thread(() -> cd.BusinessC()).start();

    static class ConditionDemo {
        volatile int signal = 1;
        Lock cl = new ReentrantLock();
        Condition c1 = cl.newCondition(), c2 = cl.newCondition(), c3 = cl.newCondition();

        public void BusinessA() {
            while (true) {
                cl.lock();
                try {
                    while (signal != 1) {
                        try {
                            c1.await();
                        } catch (InterruptedException e) {
                            e.printStackTrace();
                        }
                    }
                    sp("BusinessA in "+Thread.currentThread().getName());
                    ts(1000);
                    this.signal=2;
                    c2.signal();
                } finally {
                    cl.unlock();
                }
            }
        }
        public void BusinessB() {
            while (true) {
                cl.lock();
                try {
                    while (signal != 2) {
                        try {
                            c2.await();
                        } catch (InterruptedException e) {
                            e.printStackTrace();
                        }
                    }
                    sp("BusinessB in "+Thread.currentThread().getName());
                    ts(1000);
                    this.signal=3;
                    c3.signal();
                } finally {
                    cl.unlock();
                }
            }
        }
        public void BusinessC() {
            while (true) {
                cl.lock();
                try {
                    while (signal != 3) {
                        try {
                            c3.await();
                        } catch (InterruptedException e) {
                            e.printStackTrace();
                        }
                    }
                    sp("BusinessC in "+Thread.currentThread().getName());
                    ts(1000);
                    this.signal=1;
                    c1.signal();
                } finally {
                    cl.unlock();
                }
            }
        }
    }

其他concurrent工具类

Semaphore 信号灯

Semaphore提供了一个基于许可量的线程调度，它可以实现对有限资源的线程分配。每个线程可以申请（一个或多个）许可量，当当前许可量不足时，线程会阻塞；线程完成资源使用后，应该释放许可量，一般来说，应该释放与申请相等的许可量。注意，许可量不仅可以由线程申请和释放，也可以由外部管理，这样就提供了相当的弹性。
Semaphore的构造方法接收一个int作为许可量。当设置为1的时候，就实现了一个互斥锁。
Semaphore的构造方法允许传入一个标志以实现“公平”的分配，即先进先出FIFO的阻塞队列，但tryAcquire方法不实现此特性。

CyclicBarrier 循环路障

CyclicBarrier一个同步辅助类，它允许一组线程互相等待，直到到达某个公共屏障点 (common barrier point)。在涉及一组固定大小的线程的程序中，这些线程必须不时地互相等待，此时 CyclicBarrier 很有用。因为该 barrier 在释放等待线程后可以重用，所以称它为循环 的 barrier。
CyclicBarrier 支持一个可选的 Runnable 命令，在一组线程中的最后一个线程到达之后（但在释放所有线程之前），该命令只在每个屏障点运行一次。若在继续所有参与线程之前更新共享状态，此屏障操作 很有用。

CountDownLatch

CountDownLatch 实现了一个倒计锁，当倒计归零之前，所有被CountDownLatch所await的线程将阻塞。线程或者外部都可以调用CountDownLatch的countDown() 方法来减少计数。
当CountDownLatch的构造方法给定参数1时，就实现了一个命令式的线程控制开关，而且可以实现一对多管理。

Exchanger 交换

可以在对中对元素进行配对和交换的线程的同步点。每个线程将条目上的某个方法呈现给 exchange 方法，与伙伴线程进行匹配，并且在返回时接收其伙伴的对象。Exchanger 可能被视为 SynchronousQueue 的双向形式。

java.util.concurrent中的集合

Queue

多种阻塞队列，包括单向和双向的，线程同步，他们也可以像Java Collectyions Framework中的其他成员一样进行基本的操作，但通常不会有效执行。但主要的增强在于引入了阻塞性方法put & take ，当无法完成操作时（例如放入满队列，从空队列取）会阻塞当前线程直至队列发生变化以完成操作。

DelayQueue

Delayed 元素的一个无界阻塞队列，只有在延迟期满时才能从中提取元素。其延时依赖于元素的Delayed实现。

SynchronousQueue

一种阻塞队列，其中每个插入操作必须等待另一个线程的对应移除操作 ，反之亦然。同步队列没有任何内部容量，甚至连一个队列的容量都没有。也就是说，队列直接阻塞put和take的线程直到配对而传递。
使用公平设置为 true 所构造的队列可保证线程以 FIFO 的顺序进行访问。

PriorityBlockingQueue

优先级队列的元素按照顺序进行排序，并且提供了阻塞获取操作。不保证具有同等优先级的元素的顺序。

CopyOnWrite*

一些变体容器，其中所有可变操作（add、set 等等）都是通过对底层进行一次新的复制来实现的。这一般需要很大的开销，但是当遍历操作的数量大大超过可变操作的数量时，这种方法可能比其他替代方法更有效。