并发编程之一——JAVA线程基础

1、基础概念

1.1 什么是进程和线程

进程是程序运行资源分配的最小单位;

线程是 CPU 调度的最小单位，必须依赖于进程而存在;

线程无处不在：任何一个程序都必须要创建线程，特别是 Java 不管任何程序都必须启动一个main 函数的主线程; Java Web 开发里面的定时任务、定时器、JSP 和 Servlet、异步消息处理机制，远程访问接口RMI 等，任何一个监听事件， onclick 的触发事件等都离不开线程和并发的知识。

1.2 CPU 核心数和线程数的关系

核心数、线程数：目前主流 CPU 都是多核的。增加核心数目就是为了增加线程数，因为操作系统是通过线程来执行任务的，一般情况下它们是 1:1 对应关系，也就是说四核 CPU 一般拥有四个线程。但 Intel 引入超线程技术后，使核心数与线程数形成 1:2 的关系。

1.3 CPU 时间片轮转机制

我们平时在开发的时候，感觉并没有受 cpu 核心数的限制，想启动线程就启动线程，哪怕是在单核 CPU 上，为什么？这是因为操作系统提供了一种 CPU 时间片轮转机制。

时间片设得太短会导致过多的进程切换，降低了 CPU 效率：而设得太长又可能引起对短的交互请求的响应变差。将时间片设为 100ms 通常是一个比较合理的折衷。

在 CPU 死机的情况下，其实大家不难发现当运行一个程序的时候把 CPU 给弄到了 100%再不重启电脑的情况下，其实我们还是有机会把它 Kill掉的，我想也正是因为这种机制的缘故。

1.4 澄清并行和并发

并发：指应用能够交替执行不同的任务，比如单 CPU 核心下执行多线程并非是同时执行多个任务，如果你开两个线程执行，就是在你几乎不可能察觉到的速度不断去切换这两个任务，已达到"同时执行效果"，其实并不是的，只是计算机的速度太快，我们无法察觉到而已。

并行：指应用能够同时执行不同的任务，例：吃饭的时候可以边吃饭边打电话，这两件事情可以同时执行。

两者区别：一个是交替执行，一个是同时执行。

1.5 高并发编程的意义、好处

由于多核多线程的 CPU 的诞生，多线程、高并发的编程越来越受重视和关注。 多线程可以给程序带来如下好处：

(1)充分利用 CPU 的资源；

(2)加快响应用户的时间；

(3)可以使你的代码模块化，异步化，简单化。

1.6 多线程程序需要注意的事项

1. 线程之间的安全；
2. 线程之间的死锁；
3. 线程太多了会将服务器资源耗尽形成死机当机。

2、认识Java里的线程

2.1 线程的启动和终止

启动

启动线程的方式有：

1 、 X extends Thread; ，然后 X.start。

    /*扩展自Thread类*/
	public class UseThread extends Thread{
		@Override
		public void run() {
			super.run();
			// do my work;
			System.out.println("I am extendec Thread");
		}

        public static void main(String[] args) {
		    UseThread useThread = new UseThread();
		    useThread.start();		
	    }
	}

2 、 X implements Runnable ；然后交给 Thread 运行

    /*实现Runnable接口*/
	public class UseRunnable implements Runnable{

		@Override
		public void run() {
			// do my work;
			System.out.println("I am implements Runnable");
		}

        public static void main(String[] args) {

		    UseRunnable useRunnable = new UseRunnable();

            // 交给Thread运行。
		    new Thread(useRunnable).start();
		
	    }
	}

Thread 和 Runnable 的区别

Thread 才是 Java 里对线程的唯一抽象，Runnable 只是对任务（业务逻辑）的抽象。Thread 可以接受任意一个 Runnable 的实例并执行。

中止

线程自然终止：要么是 run 执行完成了，要么是抛出了一个未处理的异常导致线程提前结束。

stop：暂停、恢复和停止操作对应在线程 Thread 的 API 就是 suspend()、resume() 和 stop()。但是这些 API 是过期的，也就是不建议使用的。不建议使用的原因是suspend()和stop()方法调用后，线程不会释放资源（占有锁），可能会导致死锁。

中断：安全的中止则是其他线程通过调用某个线程 A 的 interrupt()方法对其进行中断操作，中断好比其他线程对该线程打了个招呼，“A，你要中断了”，不代表线程 A 会立即停止自己的工作，同样的 A 线程完全可以不理会这种中断请求。线程通过检查自身的中断标志位是否被置为 true 来进行响应，线程通过方法isInterrupted()来进行判断是否被中断，也可以调用静态方法Thread.interrupted()来进行判断当前线程是否被中断，不过 Thread.interrupted()会同时将中断标识位改写为 false。

如果一个线程处于了阻塞状态（如线程调用了 thread.sleep、thread.join、thread.wait 等），则在线程在检查中断标示时如果发现中断标示为 true，则会在这些阻塞方法调用处抛出 InterruptedException 异常，并且在抛出异常后会立即将线程的中断标示位清除，即重新设置为 false。

注意：处于死锁状态的线程无法被中断。

2.1 对Java里的线程再多一点点认识

深入理解 run()和 start()

Thread类是Java里对线程概念的抽象，可以这样理解：我们通过new Thread()其实只是 new 出一个 Thread 的实例，还没有操作系统中真正的线程挂起钩来。只有执行了 start()方法后，才实现了真正意义上的启动线程。start()方法让一个线程进入就绪队列等待分配 cpu，分到 cpu 后才调用实现的 run()方法，start()方法不能重复调用，如果重复调用会抛出异常。而 run 方法是业务逻辑实现的地方，本质上和任意一个类的任意一个成员方法并没有任何区别，可以重复执行，也可以被单独调用。

Thread其它相关方法

yield()方法：使当前线程让出 CPU 占有权，但让出的时间是不可设定的。也不会释放锁资源。注意：并不是每个线程都需要这个锁的，而且执行 yield( )的线程不一定就会持有锁，我们完全可以在释放锁后再调用 yield 方法。所有执行 yield()的线程有可能在进入到就绪状态后会被操作系统再次选中马上又被执行。

join() 方法：把指定的线程加入到当前线程，可以将两个交替执行的线程合并为顺序执行。比如在线程 B 中调用了线程 A 的 Join()方法，直到线程 A 执行完毕后，才会继续执行线程 B。

notify()：通知一个在对象上等待的线程，使其从 wait 方法返回,而返回的前提是该线程获取到了对象的锁，没有获得锁的线程重新进入 WAITING 状态。

notifyAll()：通知所有等待在该对象上的线程。

wait()：调用该方法的线程进入 WAITING 状态，只有等待另外线程的通知或被中断才会返回。需要注意，调用 wait()方法后，会释放对象的锁。wait(long)超时等待一段时间，这里的参数时间是毫秒，也就是等待长达n 毫秒，如果没有通知就超时返回。wait (long,int)对于超时时间更细粒度的控制，可以达到纳秒。

notify 和 notifyAll 应该用谁：尽可能用 notifyAll()，谨慎使用 notify()，因为 notify()只会唤醒一个线程，我们无法确保被唤醒的这个线程一定就是我们需要唤醒的线程。

等待和通知的标准范式

等待方遵循如下原则。

1）获取对象的锁。

2）如果条件不满足，那么调用对象的 wait()方法，被通知后仍要检查条件。

3）条件满足则执行对应的逻辑。

Object obj = new Object(); // 对象锁

synchronized(obj) {
    while(条件不满足){
        obj.wait();
    }
    // 对应的处理逻辑
}

通知方遵循如下原则。

1）获得对象的锁。

2）改变条件。

3）通知所有等待在对象上的线程。

Object obj = new Object(); // 对象锁

synchronized(obj) {
    // 改变条件

    // 通知所有等待在对象上的线程
    obj.notifyAll();
}

在调用 wait()、notify()系列方法之前，线程必须要获得该对象的对象级别锁，即只能在同步方法或同步块中调用 wait()方法、notify()系列方法，进入 wait()方法后，当前线程释放锁，在从 wait()返回前，线程与其他线程竞争重新获得锁，执行 notify()系列方法的线程退出调用了 notifyAll() 的 synchronized代码块的时候后，他们就会去竞争。如果其中一个线程获得了该对象锁，它就会继续往下执行，在它退出 synchronized 代码块，释放锁后，其他的已经被唤醒的线程将会继续竞争获取该锁，一直进行下去，直到所有被唤醒的线程都执行完毕。

线程的调度

Java 中的线程是通过映射到操作系统的原生线程上实现的，所以线程的调度最终取决于操作系统，而操作系统级别，OS 是以抢占式调度线程，我们可以认为线程是抢占式的。Java 虚拟机采用抢占式调度模型，是指优先让可运行池中优先级高的线程占用 CPU，如果可运行池中的线程优先级相同，那么就随机选择一个线程，使其占用 CPU。处于运行状态的线程会一直运行，直至它不得不放弃 CPU。而且操作系统中线程的优先级有时并不能和 Java 中的一一对应，所以 Java 优先级并不是特别靠谱。但是在 Java 中，因为 Java 没有提供安全的抢占式方法来停止线程，要安全的停止线程只能以协作式的方式。

守护线程

Daemon（守护）线程是一种支持型线程，因为它主要被用作程序中后台调度以及支持性工作。这意味着，当一个 Java 虚拟机中不存在非 Daemon 线程的时候，Java 虚拟机将会退出。可以通过调用Thread.setDaemon(true)将线程设置为 Daemon 线程。我们一般用不上，比如垃圾回收线程就是 Daemon 线程。

Daemon 线程被用作完成支持性工作，但是在 Java 虚拟机退出时 Daemon 线程中的 finally 块并不一定会执行。在构建 Daemon 线程时，不能依靠 finally 块中的内容来确保执行关闭或清理资源的逻辑。

等待超时模式实现一个连接池

调用场景：调用一个方法时等待一段时间（一般来说是给定一个时间段），如果该方法能够在给定的时间段之内得到结果，那么将结果立刻返回，反之，超时返回默认结果。

假设等待时间段是 T，那么可以推断出在当前时间 now+T 之后就会超时等待持续时间：REMAINING=T，超时时间：FUTURE=now+T。

/**
 *类说明：连接池的实现
 */
public class DBPool {

    /*容器，存放连接*/
    private static LinkedList<Connection> pool = new LinkedList<Connection>();

    /*限制了池的大小=20*/
    public DBPool(int initialSize) {
        if (initialSize > 0) {
            for (int i = 0; i < initialSize; i++) {
                pool.addLast(SqlConnectImpl.fetchConnection());
            }
        }
    }

    /*释放连接,通知其他的等待连接的线程*/
    public void releaseConnection(Connection connection) {
        if (connection != null) {
            synchronized (pool){
                pool.addLast(connection);
                //通知其他等待连接的线程
                pool.notifyAll();
            }
        }
    }

    /*获取*/
    // 在mills内无法获取到连接，将会返回null 1S
    public Connection fetchConnection(long mills)
            throws InterruptedException {
        synchronized (pool){
            //永不超时
            if(mills<=0){
                while(pool.isEmpty()){
                    pool.wait();
                }
                return pool.removeFirst();
            }else{
                /*超时时刻*/
                long future = System.currentTimeMillis()+mills;
                /*等待时长*/
                long remaining = mills;
                while(pool.isEmpty() && remaining > 0){
                    pool.wait(remaining);
                    /*唤醒一次，重新计算等待时长*/
                    remaining = future-System.currentTimeMillis();
                }
                Connection connection = null;
                if(!pool.isEmpty()){
                    connection = pool.removeFirst();
                }
                return connection;
            }
        }

    }
}

调用 yield() 、sleep()、wait()、notify()等方法对锁有何影响？

yield() 、sleep()被调用后，都不会释放当前线程所持有的锁。调用 wait()方法后，会释放当前线程持有的锁，而且当前被唤醒后，会重新去竞争锁，锁竞争到后才会执行 wait 方法后面的代码。调用 notify()系列方法后，对锁无影响，线程只有在 syn 同步代码执行完后才会自然而然的释放锁，所以 notify()系列方法一般都是 syn 同步代码的最后一行。