1.线程的创建

1.1继承Thread

public class ThreadDemo01 extends Thread {private String name;//这个线程的属性//通过全参构造来传参public ThreadDemo01(String name) {this.name=name;}//重写run方法@Overridepublic void run() {for(int i =1;i<=10;i++) {System.out.println(this.name+"-"+i);try {sleep(200);} catch (InterruptedException e) {// TODO Auto-generated catch blocke.printStackTrace();}}}public static void main(String[] args) {Thread t1 = new ThreadDemo01("A");Thread t2 = new ThreadDemo01("B");Thread t3 = new ThreadDemo01("C");t1.start();//启动线程t2.start();t3.start();}
}

1.2实现runnable接口

Runnalbe接口只有Run（）方法，实现该接口必须进行Run方法的重写。

public class ThreadDemo02 implements Runnable{private String name;//构造方法public ThreadDemo02(String name) {this.name = name;}//run方法@Overridepublic void run() {for(int i=1;i<=10;i++) {System.out.println(this.name+"-"+i);try {Thread.sleep(200);} catch (InterruptedException e) {e.printStackTrace();}}}public static void main(String[] args) {//常规写法
//		Thread t1 =new Thread(new ThreadDemo02("A"));
//		Thread t2 =new Thread(new ThreadDemo02("B"));
//		Thread t3 =new Thread(new ThreadDemo02("C"));
//		
//		t1.start();
//		t2.start();
//		t3.start();//匿名内部类写法new Thread(new Runnable() {// Runnable()接口@Overridepublic void run() {for (int i = 1; i <= 10; i++) {System.out.println(Thread.currentThread().getName() + "-" + i);try {Thread.sleep(200);} catch (InterruptedException e) {e.printStackTrace();}}}});//		new Thread(()->{
//			for(int i=1;i<=10;i++) {
//				System.out.println(Thread.currentThread().getName()+"-"+i);
//				try {
//					Thread.sleep(200);
//				} catch (InterruptedException e) {
//					e.printStackTrace();
//				}
//			}
//		}).start();}}

Runnable接口的实现是我们最常用的方法，因为继承的机会是宝贵的，我们尽量使用接口。
Runnable接口的实现来创建线程有3种方式：1、常规写法。2.匿名内部类。3.拉姆达表达式（因为Runnable接口是函数式接口）

1.3 实现Callable接口

Callable接口也是对Runnable接口的继承，但是两者最大的不同是Callable可以有返回值。。。。。
创建线程是可调用Run方法。。
FutureTask类创建线程。。。

import java.util.concurrent.Callable;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.FutureTask;public class ThreadDemo03 implements Callable<Integer>{//此接口可以有返回值@Overridepublic Integer call() throws Exception {int s =0;for(int i=1;i<=1000;i++) {s+=i;}return s;}public static void main(String[] args) {FutureTask<Integer> ft =new FutureTask<Integer>(new ThreadDemo03());ft.run();try {System.out.println("结果为："+ft.get());} catch (InterruptedException e) {// TODO Auto-generated catch blocke.printStackTrace();} catch (ExecutionException e) {// TODO Auto-generated catch blocke.printStackTrace();}}}

2.线程就绪

Thread t =new Thread();
t.start();//启动（就绪）线程

3.线程运行

4.线程阻塞

4.1 sleep（）

sleep（）是static方法sleep() 是static静态的方法，他不能改变对象的机锁，当一个synchronized块中调用了sleep() 方法，线程虽然进入休眠，但是对象的机锁没有被释放，其他线程依然无法访问这个对象。
总的来说，sleep()方法不会释放锁。

4.2 join（）

主线程创建并启动子线程，如果子线程中要进行大量的耗时运算，主线程往往将早于子线程结束之前结束。如果主线程想等待子线程执行完成之后再结束，比如子线程处理一个数据，主线程要取得这个数据中的值，就要用到 join() 方法。

//测试阻塞方法：join()
public class ThreadBlockDemo01 extends Thread{@Overridepublic void run() {for(int i=1;i<10;i++) {System.out.println(getName()+":"+i);try {sleep(200);} catch (InterruptedException e) {// TODO Auto-generated catch blocke.printStackTrace();}}}public static void main(String[] args) throws InterruptedException {Thread t1 =new ThreadBlockDemo01();Thread t2 =new ThreadBlockDemo01();Thread t3 =new ThreadBlockDemo01();t1.start();t1.join();t2.start();t3.start();}
}

4.3 yield()

yield()让当前正在运行的线程回到可运行状态，以允许具有相同优先级的其他线程获得运行的机会。因此，使用yield()的目的是让具有相同优先级的线程之间能够适当的轮换执行。

大多数情况下，yield()将导致线程从运行状态转到可运行状态，但有可能没有效果。

//测试阻塞方法：yield():暂时让出cpu时间片
public class ThreadBlockDemo02 extends Thread{@Overridepublic void run() {for(int i=1;i<=10;i++) {if(i%2==0) {//如果i是偶数，暂时让出cpu时间片Thread.yield();}System.out.println(getName()+":"+i);try {sleep(300);} catch (InterruptedException e) {// TODO Auto-generated catch blocke.printStackTrace();}}}public static void main(String[] args) {Thread t1 = new ThreadBlockDemo02();Thread t2 = new ThreadBlockDemo02();Thread t3 = new ThreadBlockDemo02();t1.start();t2.start();t3.start();}
}

4.4 wait()

wait()方法会释放锁，一般和synchronized()和notifyAll() 一起使用。。。。。

5.线程死亡