线程的概念和使用

1. 线程的概念

在了解线程的使用之前我们先来了解一下线程有关概念。
进程： 例如一个xxx.exe程序，这个程序是一个静态的概念，它被扔在硬盘上也没人理他，但是当你双击运行它时叫做一个进程。进程相对于程序来说它是一个动态的概念。
线程： 作为一个进程里面最小的执行单元它就叫一个线程，用简单的话讲就是一个进程（程序）里不同的执行路径就叫做一个线程。
示例：体验什么是线程

import java.util.concurrent.TimeUnit;
public class T1 {	
	private static class T01 extends Thread {
		@Override														
		public void run() {
			for(int i=0; i<10; i++) {
				try {
					TimeUnit.MICROSECONDS.sleep(1);
				} catch (InterruptedException e) 
					{ e.printStackTrace();
				}
				System.out.println("T01");
			}
		}
	}

	public static void main(String[] args) {
		//new T01().run();
		new T01().start();
		for(int i=0; i<10; i++) {
			try {
				TimeUnit.MICROSECONDS.sleep(1);
			} catch (InterruptedException e) 
				{ e.printStackTrace();
			}
			System.out.println("main");
		}
	}
}

观察上面程序的输出，你会看到两种结果：

• 字符串“T01”全部输出后“Main”才开始输出 //new T01().run();
• 字符串“T01”和“Main”的交替输出 //new T01().start();

这两种方法启动线程有如下区别：

• .run()方法相当于先执行run()的内容，再接着执行main方法的内容，在程序执行过程中只有一条执行路径。
• .start()方法相当于启动run()方法的同时，main方法和run()方法同时运行，但要知道这个同时并不是严格意义上的同时。

2. 线程的使用

2.1. 创建线程

1. 继承Thread类并重写run()方法，启动时直接调用即可。
2. 定义一个类并实现Runnable接口，依然重写run()方法。使用这种方法启动线程时必须new一个thread并传入实现runnable接口的类对象再调用start方法。
3. 定义一个类并实现Callable接口并重写call()方法。

2.2. 启动线程

1. 继承thread，new Thread().start()
2. 实现runnable接口，new Thread(Runnable).start()
3. 通过线程池启动，Executors.newCachedThreadPool()或者FutureTask + Callable
   但是通过线程池启动也是用的前两种之一，这有些吹毛求疵的意思。

示例：线程的创建和启动

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

public class Test01 {
    //创建线程的两种方式
    //1.继承Thread类并重写run方法
    static class MyThread extends Thread {
        @Override
        public void run() {
            System.out.println("Hello MyThread!");
        }
    }0
    //2.定义一个类并实现Runnable接口，依然重写run方法
    static class MyRun implements Runnable {
        @Override
        public void run() {
            System.out.println("Hello MyRun!");
        }
    }
	//3.实现Callable接口，重写call方法，使用该种方式创建的线程可以有返回值
    static class MyCall implements Callable<String> {
        @Override
        public String call() { System.out.println("Hello MyCall"); return "success";
        }
    }
    
    //启动线程的5种方式(含变形)
    public static void main(String[] args) {
    	//1. 继承Thread类，直接调用即可
        new MyThread().start();
        //2. 实现Runnable接口，使用这种方法启动线程时必须new一个thread并传入实现runnable接口的类对象再调用start方法
        new Thread(new MyRun()).start();
        //3. 第二种的变形，带lambda表达式
        new Thread(()->{
            System.out.println("Hello Lambda!");
        }).start();

		//4. 以下两种通过线程池创建
        Thread t = new Thread(new FutureTask<String>(new MyCall()));
        t.start();

        ExecutorService service = Executors.newCachedThreadPool(); 
        service.execute(()->{
            System.out.println("Hello ThreadPool");
        });
        service.shutdown();
    }
}

2.3. 线程的三个方法

2.3.1. Thread.sleep

Thread.sleep() ，意思就是睡眠，当前线程暂停一段时间让给别的线程去运行。根据你设置的时长，等睡眠到规定的时间自动复活。

static void testSleep() { 
		new Thread(()->{ 
			for(int i=0; i<100; i++) { 
				System.out.println("A" + i); 
				try { 
					Thread.sleep(500);
					//TimeUnit.Milliseconds.sleep(500)
				} catch (InterruptedException e) 
					{ e.printStackTrace();
				}
			}
		}).start();
	}

2.3.2. Thread.yield

Thread.yield()，就是让当前正在执行的线程停下来进入等待队列，回到等待队列里之后，在系统不同的调度算法下依然有可能把这个线程拿回来继续执行，当然，更大的可能性是把原来等待的那些拿出一个来执行，所以yield的意思是我让出一下CPU，后面谁能抢到我不管。

static void testYield() {
		new Thread(()->{
			for(int i=0; i<100; i++) {
				System.out.println("A" + i);
				//设置条件触发yield
				if(i%10 == 0) Thread.yield();
			}
		}).start();
		new Thread(()->{
			for(int i=0; i<100; i++) {
				System.out.println("------------B" + i);
				if(i%10 == 0) Thread.yield();
		}
	}).start();
}

2.3.3. Thread.join

Thread.join()，意思就是在自己当前线程加入需要调用的线程，并使本线程等待调用的线程运行结束后再继续执行。t1和t2两个线程，在t1的某个点上调用了t2.join,它会跑到t2去运行，t1等待t2运行完毕继续t1运行 （自己join自己没有意义）

static void testJoin() {
		Thread t1 = new Thread(()->{
			for(int i=0; i<100; i++) {
				System.out.println("A" + i);
				try {
					Thread.sleep(500);
					//TimeUnit.Milliseconds.sleep(500)
				} catch (InterruptedException e) {
					e.printStackTrace();
				}
			}
		});
		Thread t2 = new Thread(()->{
			try {
				//在此处join t1线程
				t1.join();
			} catch (InterruptedException e) { e.printStackTrace();
		}
		for(int i=0; i<100; i++) {
			System.out.println("A" + i);
			try {
				Thread.sleep(500);
				//TimeUnit.Milliseconds.sleep(500)
			} catch (InterruptedException e) 
				{ e.printStackTrace();
				}
			}
		});
		t1.start();
		t2.start();
	}
}

3. 线程的状态

常见的线程状态有六种： 创建、就绪、运行、超时等待、等待、阻塞、结束。
上面这些状态全是由JVM管理的，但JVM管理的时候也要通过操作系统，因为JVM也只是跑在操作系统上的一个“普通程序”。
在代码中可以通过线程的getState()方法获取线程当前的状态。

System.out.println(t.getState());

• 当我们new了一个线程，还没有调用start()时该线程处于新建/创建状态 。
• 线程对象调用start()方法时候，他会被线程调度器执行，也就是交给操作系统来执行了，那么操作系统来执行的时候，这整个的状态叫Runnable。Runnable内部有两个状态：Ready就绪状态/Running运行状态。就绪状态是说扔到CPU的等待队列里面去排队等待CPU运行，等真正扔到CPU上去运行的时候才叫Running运行状态。（调用yiled方法时候会从Running状态跑到Ready状态去，线程被调度器选中执行的时候又从Ready状态跑到Running状态去）
• 在Runnable这个状态里头还有其他一些状态的变迁 TimedWaiting等待、Waiting等待、Blocked阻塞，在同步代码块的情况下没得到锁就会进入阻塞状态，获得锁的时候是就绪状态运行。在运行的时候如果调用了线程的wait()、join()、park()则进入Waiting状态（无限等待），调用notify()、notifiAll()、unpark()就又回到Running状态。Timed Waiting（计时等待） 按照时间等待，等时间结束自己就回去了，Thread.sleep(time)、o.wait(time)、t.jion(time)、LockSupport.parkNanos()、LockSupport.parkUntil()这些都是关于时间等待的方法。
• 如果线程顺利的执行完了就会进入 Teminated****结束状态。