**
线程生命周期图如下：
**
阻塞状态（Blocked）：处于运行状态中的线程由于某种原因，暂时放弃对CPU的使用权，停止执行，此时进入阻塞状态，直到其进入到就绪状态，才有机会再次被CPU调用以进入到运行状态。根据阻塞产生的原因不同，阻塞状态又可以分为三种：
1.等待阻塞：运行状态中的线程执行wait()方法，使本线程进入到等待阻塞状态；
2.同步阻塞 – 线程在获取synchronized同步锁失败(因为锁被其它线程所占用)，它会进入同步阻塞状态；
3.其他阻塞 – 通过调用线程的sleep()或join()或发出了I/O请求时，线程会进入到阻塞状态。当sleep()状态超时、join()等待线程终止或者超时、或者I/O处理完毕时，线程重新转入就绪状态。
创建线程的方式：
1.继承Thread类
2.实现Runnable接口
3.匿名内部类的方式
4.带有返回值的线程，实现callable接口
5.定时器
6.线程池
7.Lambda表达式实现
1>.自定义<线程类>，继承Thread类，重写run()方法。
public class ExtendsThread extends Thread{
public ExtendsThread() {
//调用默认构造函数，线程类名称为默认名称thread-0,1,2,3..
super();
}
public ExtendsThread(String name) {
//调用父类构造函数，为自定义线程类命名
super(name);
}
@Override
public void run() {
for(int i =0;i<5;i++) {
System.out.println(i+":"+Thread.currentThread().getName());
}
//一旦被守护线程执行结束，那么守护线程也会马上结束，不在执行
// @Override
// public void run() {
// while (true) {
// System.out.println(Thread.currentThread().getName() + "正在执行.......");
// }
}
public static void main(String[] args) {
//new 一个线程类，调用其start()方法，就可以启动一个线程
ExtendsThread t1 = new ExtendsThread();
ExtendsThread t2 = new ExtendsThread("t2");
t1.start();
t2.start();
// ExtendsThread t3 = new ExtendsThread("t3");
// t3.setDaemon(true);
// t3.start();
System.out.println(Thread.currentThread().getName() + "正在执行");
}
}
输出结果：
0:t1
1:t1
2:t1
3:t1
4:t1
0:Thread-0
1:Thread-0
2:Thread-0
3:Thread-0
4:Thread-0
2>.自定义<线程任务>实现Runnable接口方式创建线程。
public class RunnableThread implements Runnable {
@Override
public void run() {
for(int i=0;i<5;i++) {
System.out.println(i+":"+Thread.currentThread().getName()+",正在执行......");
}
}
public static void main(String[] args) {
//任务类并不能直接启动线程，将任务类传给线程对象，通过线程类启动线程
RunnableThread task = new RunnableThread();
Thread t1 = new Thread(task,"t1");
t1.start();
}
}
输出结果：
0:t1正在执行......
1:t1正在执行......
2:t1正在执行......
3:t1正在执行......
4:t1正在执行......
3>.匿名内部类方式创建线程。
有时我们创建的线程任务只需要执行一次，可以使用匿名内部类方式创建线程：
public class AnnoyInnerThread {
public static void main(String[] args) {
//new Threa(Runnable run)方式匿名内部类线程
new Thread(new Runnable() {
@Override
public void run() {
System.out.println("匿名内部类线程 "+Thread.currentThread().getName()+"正在执行.....");
}
},"inner1").start();
//new Thread类方式匿名内部类线程
new Thread("inner2") {
public void run() {
System.out.println("匿名内部类线程 "+Thread.currentThread().getName()+"正在执行.....");
};
}.start();
}
}
输出结果：
匿名内部类线程 inner1正在执行.....
匿名内部类线程 inner2正在执行.....
4.实现Callable 接口方式：
public class CallableThread implements Callable<String> {
@Override
public String call() throws Exception {
System.out.println(Thread.currentThread().getName()+"线程正在进行复杂的运算......");
return "success!";
}
public static void main(String[] args) throws InterruptedException, ExecutionException {
CallableThread call = new CallableThread();
FutureTask<String> task = new FutureTask<>(call);
//任务类最终都要交给线程类Thread类启动的
Thread t = new Thread(task,"callable");
t.start();
String result = task.get();
System.out.println("任务计算结果为:" + result);
}
}
输出结果：
callable 线程正在进行复杂的运算........
任务计算结果为:success!
5>.定时器方式创建线程
这里的timetask也是实现了runnable接口的。这种创建线程方式可以用作定时任务，跑批处理等，可以使用专门的框架来实现这种创建线程的需求，如quartz。
public class TimerThread {
public static void main(String[] args) {
Timer timer = new Timer();
timer.scheduleAtFixedRate(new TimerTask() {
@Override
public void run() {
System.out.println("任务正在执行，时间:"+System.currentTimeMillis());
}
}, 0, 2000);
}
}
输出结果：
任务正在执行，时间:1555142793061
任务正在执行，时间:1555142795061
任务正在执行，时间:1555142797061
任务正在执行，时间:1555142799062
任务正在执行，时间:1555142801062
。。。。。
6>.线程池方式创建
public class PoolThread {
public static void main(String[] args) {
ExecutorService fixPool = Executors.newFixedThreadPool(5);
//根据任务多少自动创建线程和销毁线程数量，线程数量是浮动的，自动管理。
// ExecutorService cachePool = Executors.newCachedThreadPool();
for (int i = 0; i < 10; i++) {
int tmp = i;
fixPool.execute(new Runnable() {
@Override
public void run() {
System.out.println("正在执行第" + tmp + "次任务!" + Thread.currentThread().getName());
}
});
}
// fixPool.shutdown();
}
}
输出结果：
正在执行第0次任务!pool-1-thread-1
正在执行第1次任务!pool-1-thread-2
正在执行第2次任务!pool-1-thread-3
正在执行第4次任务!pool-1-thread-5
正在执行第5次任务!pool-1-thread-2
正在执行第3次任务!pool-1-thread-4
正在执行第7次任务!pool-1-thread-1
正在执行第9次任务!pool-1-thread-3
正在执行第6次任务!pool-1-thread-2
正在执行第8次任务!pool-1-thread-4
7>.spring3后对多线程的支持。
参考文章： https://blog.csdn.net/king_kgh/article/details/76022136
感觉这篇文章写得很好了。
8>.Lambda表达式对多线程的支持。
待续。。。。