多线程概念

线程的生命周期

状态

• NEW：初始状态，线程被创建，但是还没有调用start方法。
• RUNNABLE：运行状态，Java线程中把操作系统中的就绪(READY)和运行(RUNNING)两种状态笼统的称作运行中。
• BLOCKED：阻塞状态，表示线程阻塞于锁。
• WAITING：等待状态，表示线程进入等待状态，进入该状态表示当前线程需要等待其他线程做出一些特定动作。
• TIME_WAITING：超时等待状态，该状态不同于WAITING，他是可以在指定时间自行返回的。
• TERMINATED：终止状态，表示当前线程已经执行完成。
  

创建线程方式

• 继承Thread类
• 实现runnable接口
• 匿名内部类创建线程对象
• 创建带返回值的线程（Callable接口）
• 定时器Timer
• 线程池创建线程
• 利用java8新特性 stream 实现并发

package com.mine.concurrent.multi_thread;

import java.util.Timer;
import java.util.TimerTask;
import java.util.concurrent.Callable;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.FutureTask;

public class CreatThreadDemo {
	public static void main(String[] args) throws Exception {
		// 第一种创建方式
		System.out.println("========第一种创建方式========");
		CreatThreadDemo1 demo1 = new CreatThreadDemo1();
		demo1.start();
		
		// 第二种创建方式
		System.out.println("========第二种创建方式========");
		CreatThreadDemo2 demo2 = new CreatThreadDemo2();
		new Thread(demo2).start();
		
		// 第三种创建方式
		System.out.println("========第三种创建方式========");
		new Thread(new Runnable() {
			
			public void run() {
				System.out.println("匿名内部类启动了");
			}
		}).start();
		
		// 第四种创建方式
		System.out.println("========第四种创建方式========");
		FutureTask<String> futureTask = new FutureTask<String>(new CreatThreadDemo4());
		new Thread(futureTask).start();
		System.out.println(futureTask.get());
		
		// 第五种创建方式
		System.out.println("========第五种创建方式========");
		final Timer time = new Timer();
		time.schedule(new TimerTask() {
			private int count;
			@Override
			public void run() {
				this.count++;
				System.out.println("TimerTask start" + this.count);
				if (this.count>=5) {
					time.cancel();
				}
				System.out.println("TimerTask end" + this.count);
			}
		}, 0, 1000);
		
		// 第六种创建方式
		System.out.println("========第六种创建方式========");
		// 创建固定数量（10）的线程
		ExecutorService threadPool = Executors.newFixedThreadPool(10);
		for (int i=1; i<=20; i++) {
			threadPool.execute(new Runnable() {
				public void run() {
					System.out.println(Thread.currentThread().getName() + "线程执行");
				}
			});
		}
		threadPool.shutdown();
	}
}

class CreatThreadDemo1 extends Thread {
	@Override
	public void run() {
		try {
			Thread.sleep(200);
		} catch (InterruptedException e) {
			e.printStackTrace();
		}
		System.out.println("CreatThreadDemo1");
	}
}

class CreatThreadDemo2 implements Runnable {
	public void run() {
		System.out.println("CreatThreadDemo2");
	}
}

class CreatThreadDemo4 implements Callable<String> {

	public String call() throws Exception {
		Thread.sleep(2000);
		System.out.println("CreatThreadDemo4");
		return "ok";
	}
	
}

java线程模型

• 内核线程：由操作系统创建的线程。
• 用户线程：目前java中创建的线程都是用户线程，它在内核线程之上，不直接与操作系统交互。java创建线程是通过调用Thread类的start0方法创建的，start0是一个native方法。

用户线程与内核线程之间有三种常见关系：

• 一对一模型：一个用户线程对应一个核心线程。
• 多对一模型：多个用户线程对应一个核心线程。
• 多对多模型：多个用户线程对应多个核心线程。

因为目前java使用的是一对一模型，所以对于计算密集型的程序，这样的程序消耗CPU较大，通常线程数不要超过CPU的核心数；对于IO密集型程序来说，IO占用时间长，CPU空闲率比较高，所以可以设置线程数高于CPU的核心数。