java并发编程基础

  java从诞生开始就明智的选择了内置对多线程的支持，这使得java语言相比同一时期的其余语言具备明显的优点。线程做为操做系统调度的最小单元，多个线程可以同时执行，这将显著提高程序性能，在多核环境中表现的更加明显。可是，过多的建立线程和对线程的不当管理也容易形成问题。

  4.1 线程简介

4.1.1 什么是线程

    在一个进程中能够建立多个线程，这些线程都拥有各自的计数器、堆栈和局部变量等属性，而且可以访问共享的内存变量。处理器在这些线程上高速切换，让使用者感受这些线程在同时执行。

  一个java程序从main方法开始执行，而后按照既定的代码逻辑执行，看似没有其余线程参与，但实际上java程序天生就是多线程程序，

public class MultiThread {

    public static void main(String[] args) {
        // 获取Java线程管理MXBean
        ThreadMXBean threadMXBean = ManagementFactory.getThreadMXBean();
        // 不须要获取同步的monitor和synchronizer信息，仅仅获取线程和线程堆栈信息
        ThreadInfo[] threadInfos = threadMXBean.dumpAllThreads(false, false);
        // 遍历线程信息，仅打印线程ID和线程名称信息
        for (ThreadInfo threadInfo : threadInfos) {
            System.out.println("[" + threadInfo.getThreadId() + "] " + threadInfo.getThreadName());
        }
    }
}

能够看到，一个java程序的运行不单单是main方法的运行，而是main线程和多个其余线程的同时运行。

4.1.2 为何要使用线程

主要有如下几点

一、更多的处理器核心

二、更快的响应时间

三、更好的编程模型

4.1.3 线程的状态

java线程在运行的生命周期中可能处于下6种不一样的状态，在给定的一个时刻，线程只能处于其中一个状态。

public class ThreadState {

    private static Lock lock = new ReentrantLock();

    public static void main(String[] args) {
        new Thread(new TimeWaiting(), "TimeWaitingThread").start();
        new Thread(new Waiting(), "WaitingThread").start();
        // 使用两个Blocked线程，一个获取锁成功，另外一个被阻塞
        new Thread(new Blocked(), "BlockedThread-1").start();
        new Thread(new Blocked(), "BlockedThread-2").start();
        new Thread(new Sync(), "SyncThread-1").start();
        new Thread(new Sync(), "SyncThread-2").start();
    }

    /**
     * 该线程不断的进行睡眠
     */
    static class TimeWaiting implements Runnable {
        @Override
        public void run() {
            while (true) {
                SleepUtils.second(100);
            }
        }
    }

    /**
     * 该线程在Waiting.class实例上等待
     */
    static class Waiting implements Runnable {
        @Override
        public void run() {
            while (true) {
                synchronized (Waiting.class) {
                    try {
                        Waiting.class.wait();
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }
            }
        }
    }

    /**
     * 该线程在Blocked.class实例上加锁后，不会释放该锁
     */
    static class Blocked implements Runnable {
        public void run() {
            synchronized (Blocked.class) {
                while (true) {
                    SleepUtils.second(100);
                }
            }
        }
    }

    static class Sync implements Runnable {

        @Override
        public void run() {
            lock.lock();
            try {
                SleepUtils.second(100);
            } finally {
                lock.unlock();
            }

        }

    }
}