目录

一 .  创建线程

    1) 继承Thread类 

   2) 使用Runnable 来创建线程

 3) 继承Thread , 使用匿名内部类

 4)  实现Runnable , 使用匿名内部类

5)  lambda 表达式 创建线程(常用)

二 . Thread 构造方法 与 常用方法

1. 无参构造 Thread()

2. 只有Runnable 参数 Thread(Runnable)

 3. 带有Runnable 与 String  的构造方法 Thread(Runnable,String)

4. 只带有String 参数的构造方法 Thread(String)

 ​Thread 常见属性

1) 获得当前线程的引用

2) 获取ID

3) 获取名称

4) 获取优先级

5) 获取线程的状态

6) 是否存活

7)  是否被中断

 8) 是否后台线程

关于线程中的 run() 方法

三 . 线程的状态

1) 线程休眠

2) 线程中断

3) 线程等待

总结 : 

一 .  创建线程

    1) 继承Thread类 

class MyThread extends Thread {@Overridepublic void run() {System.out.println("通过继承来创建线程");}
}
public class Demo1 {public static void main(String[] args) {Thread t = new MyThread();t.start();}
}

   2) 使用Runnable 来创建线程

这种写法通过实现Runnable , 来描述线程中要执行的任务

class MyRunnable implements Runnable {@Overridepublic void run() {System.out.println("使用实现Runnable 接口 创建线程");}
}
public class Demo2 {public static void main(String[] args) {Thread t = new Thread(new MyRunnable());t.start();}
}

 3) 继承Thread , 使用匿名内部类

public class Demo3 {public static void main(String[] args) {Thread t = new Thread() {@Overridepublic void run() {System.out.println("继承Thread,匿名内部类");}};t.start();}
}

 4)  实现Runnable , 使用匿名内部类

实现方法跟上面相同.(实现了Runnable,重写了run()方法)

public class Demo4 {public static void main(String[] args) {Thread t = new Thread(new Runnable() {@Overridepublic void run() {System.out.println("实现Runnable 接口,匿名内部类");}});t.start();}
}

5)  lambda 表达式 创建线程(常用)

public class Demo5 {public static void main(String[] args) {Thread t = new Thread(() -> {System.out.println("lambda表达式");});}
}

总结 : 通常认为Runnable 这种写法更好一点 ~~ 能够做到让线程和线程执行的任务, 更好的进行解耦.  (写代码希望 : 高内聚, 底耦合)

Runnable 单纯的只是描述了一个任务 ~ 至于这个任务是要通过一个进程来执行,还是线程执行,或者是线程池来执行,还是协程来执行, Runnable本身别不关心,Runnable里面的代码也不关心.

二 . Thread 构造方法 与 常用方法

在这里主要将一下几个构造方法 : 

1. 无参构造 Thread()

2. 只有Runnable 参数 Thread(Runnable)

 3. 带有Runnable 与 String  的构造方法 Thread(Runnable,String)

4. 只带有String 参数的构造方法 Thread(String)

 ​Thread 常见属性

Thread 的几个常见属性

1) 获得当前线程的引用

Thread.currentThread();

2) 获取ID

3) 获取名称

4) 获取优先级

public static void main(String[] args) {Thread t = new Thread(() -> {//获取当前线程的IDSystem.out.println(Thread.currentThread().getId());//获取当前线程的名称System.out.println(Thread.currentThread().getName());//获取当前线程的优先级System.out.println(Thread.currentThread().getPriority());System.out.println("hello");});t.start();}

5) 获取线程的状态

这里的状态会分为很多种,在后面会重点介绍.

6) 是否存活

这里的线程存活指的是系统内核里的那个线程,是否存活的

public static void main(String[] args) {Thread t = new Thread(() -> {while (true) {//空}});System.out.println(t.isAlive());t.start();System.out.println(t.isAlive());}

7)  是否被中断

这是线程中的一个标志位 默认值为false.

public class Demo11 {public static void main(String[] args) {Thread t = new Thread(() -> {System.out.println("hello");});t.start();System.out.println(t.isInterrupted());}
}

 我们通过interrupt() 方法就可以将这个标志位由false 变为 true;

public static void main(String[] args) {Thread t = new Thread(() -> {System.out.println("hello");});t.start();System.out.println(t.isInterrupted());t.interrupt();System.out.println(t.isInterrupted());}

 8) 是否后台线程

什么是前台线程 ??  什么是后台线程??

后台线程不阻止java进程结束.

即使后线程还没执行完, java进程该结束就结束了~~

前台线程更好相反

前台线程会阻止java线程结束, 必须得java进程中所有的前台线程都执行完 java进程才结束.

通过Thread 创建出来的线程都是前台线程,

可以通过setDaemon() 将前台设置为后台

public static void main(String[] args) {Thread t = new Thread(() -> {while (true) {//空}});t.start();System.out.println(t.isDaemon());}

调用setDaemon()

public static void main(String[] args) {Thread t = new Thread(() -> {while (true) {//空}});System.out.println(t.isDaemon());//注意这里在设置前后台线程时//这个语句要放在t.start()之前t.setDaemon(true);t.start();System.out.println("结束");}

关于线程中的 run() 方法

如果通过 t.run() 去调用 ,  那么它会是一个普通的方法去执行, 存在main线程中

public static void main(String[] args) {Thread t = new Thread(() -> {int j = 5;while (j-- > 0) {System.out.println("t:" + j);}});t.run();int i = 10;while (i-- > 0) {System.out.println("main :" + i);}}

通过上述的运行结果我们可以看出,先执行完run()方法,然后再向后执行

如果将t.run() 转换为 t.start()

run() 方法补充 : 

 多线程如何执行 (补充): 

三 . 线程的状态

1) 线程休眠

Thread.sleep()  : 让当前线程进入休眠 , 括号里面放入休眠的时间

Thread.sleep(1000) : 让当前线程休眠1秒  

public static void main(String[] args) {Thread t = new Thread(() -> {while (true) {System.out.println("hello");try {Thread.sleep(1000);} catch (InterruptedException e) {e.printStackTrace();}}});t.start();System.out.println("------");}

hello在打印的时候也是 1秒打印一个

2) 线程中断

两种方式 : 1. 自己设立一个标志 来控制线程的运行

                  2. 使用线程中的isInterrupted()

1. 手动设置一个标志位 , 来控制线程是否要结束执行~~

t 线程 与 main 线程  都是在一个进程内, 因此它们用了同一份虚拟地址空间.

因此 , 在main线程中修改的isQuit 就会该变 t 线程中的isQuit.

public class Demo15 {public static boolean isQuit = false;public static void main(String[] args) {Thread t = new Thread(() -> {while (!isQuit) {System.out.println("hello");try {Thread.sleep(1000);} catch (InterruptedException e) {e.printStackTrace();}}});t.start();try {Thread.sleep(3000);} catch (InterruptedException e) {e.printStackTrace();}isQuit = true;System.out.println("中断t线程");}
}

2. 使用isInterrupted() 来修改线程的标志位

public class Demo16 {public static void main(String[] args) {Thread t = new Thread(() -> {while (!Thread.currentThread().isInterrupted()) {System.out.println("hello");try {Thread.sleep(1000);} catch (InterruptedException e) {e.printStackTrace();}}});t.start();try {Thread.sleep(2000);} catch (InterruptedException e) {e.printStackTrace();}t.interrupt();System.out.println("-----");}
}

通过上述的输出结果 : 代码报错之后 , 没有中断 t 线程,还是在继续的执行程序

问题如下 :

修改后的代码 : 

public class Demo16 {public static void main(String[] args) {Thread t = new Thread(() -> {while (!Thread.currentThread().isInterrupted()) {System.out.println("hello");try {Thread.sleep(1000);} catch (InterruptedException e) {e.printStackTrace();break;}}});t.start();try {Thread.sleep(2000);} catch (InterruptedException e) {e.printStackTrace();}t.interrupt();System.out.println("-----");}
}

这样当它打印完异常日志后 , 我们直接让它break 退出循环.

3) 线程等待

实现一个代码通过 t 线程让i 自增10次

public class Demo17 {private static int i = 0;public static void main(String[] args) {Thread t = new Thread(() -> {for (int j = 0; j < 10; j++) {i++;}});t.start();System.out.println(i);System.out.println("main线程结束");}
}

 输出结果为 0 

问题如下 : 

 修改代码 : 

public class Demo17 {private static int i = 0;public static void main(String[] args) {Thread t = new Thread(() -> {for (int j = 0; j < 10; j++) {i++;}});t.start();try {t.join();} catch (InterruptedException e) {e.printStackTrace();}System.out.println(i);System.out.println("main线程结束");}
}

对于线程等待的补充 : 

上述 t.join()  这句代码是在main线程中, 因此就是让main线程等待 t 线程执行完成.

要注意这里的等待与被等待对象.

另外我们还可以设置等待的时间

t.join(2000) : 表示main线程只等待 t 线程2秒钟. 然后就继续去执行main方法其余语句.

总结 : 

综上的线程的状态, 我们可以构造一个图