文章目录
- 1.java如何进行多线程编程
- 1.1 最基础的多线程代码
- 1.2 线程的优势
- 2.java中创建线程的方法
- 2.1 继承Thread 重写run
- 2.2 实现Runnable 接口
- 2.3 使用匿名的内部类，继承 Thread
- 2.4 使用匿名类。继承 Runnable
- 2.5 使用 Lambda 表达式（最简答、最推荐）
1.java如何进行多线程编程
Thread 是java操作多线程最核心类。
使用Thread不需要import导入别的包，因为它是在java.lang下面
1.1 最基础的多线程代码
package thread;
class MyThread extends Thread{
//在此类中重写run方法
@Override
public void run() {
System.out.println("hello world");
}
}
public class ThreadDemo1 {
public static void main(String[] args) {
Thread thread = new MyThread();
thread.start();//线程中的特殊方法 - 创建一个线程
}
}
在thread包中创建一个对象，Mythread子类继承Thread父类。
重写Thread类中的run方法输出hello world。
start是线程中的特殊方法，在这里的作用是创建一个新的线程，而不是调用run。
新的线程负责调用run方法来输出hello world。
新的进程调用操作系统的API，通过操作系统内核创建新线程的PCB。
并且把要执行的指令交给这个PCB。
当这个PCB被调度到CPU上的时候，也就执行到了线程run方法中的代码了。
如果run方法执行完毕，这个新的线程会销毁。
1.2 线程的优势
改动一下上面的代码：
package thread;
class MyThread extends Thread{
//在此类中重写run方法
@Override
public void run() {
while (true) {
System.out.println("hello world");
}
}
}
public class ThreadDemo1 {
public static void main(String[] args) {
Thread thread = new MyThread();
thread.start();//线程中的特殊方法 - 创建一个线程
while (true) {
System.out.println("hello java");
}
}
}
如果此时的代码时非线程的，程序会死循环的输出 hello world，并且没有机会执行 hello java
但是实际情况是，这两条输出语句都会执行，并且都是死循环。
为了方便观察，调用sleep设置睡眠时间为1秒。
package thread;
class MyThread extends Thread{
//在此类中重写run方法
@Override
public void run() {
while (true) {
System.out.println("hello world");
//睡一会儿
try {
Thread.sleep(1000);
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
}
public class ThreadDemo1 {
public static void main(String[] args) {
Thread thread = new MyThread();
thread.start();//线程中的特殊方法 - 创建一个线程
while (true) {
System.out.println("hello java");
//睡一会儿
try {
Thread.sleep(1000);
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
}
先执行 hello world 还是先执行 hello java 是不确定的。
操作系统调度线程的时候，是“抢占式执行的”，具体哪个先哪个后，是不确定的。
这要取决与操作系统的调度器具体的实现策略。
虽然有优先级，但是在应用程序层面上无法修改。
从应用程序（代码）的角度，看到的效果，就好像是线程的调度效果好像是随机的一样。
内核里本身并不是随机的，但是干预的元素太多了，并且应用程序这一层也无法感知到细节，就只能认为是随机的了。
抢占式执行，随机访问就是线程安全问题的罪魁祸首。
如果其中一条语句无法输入，不会影响另一条语句。
把输出 hello world 的语句给屏蔽了，但是不会影响输出 hello java
class MyThread extends Thread{
//在此类中重写run方法
@Override
public void run() {
while (true) {
//System.out.println("hello world");
//睡一会儿
try {
Thread.sleep(1000);
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
}
就像是，张三和李四去学校，张三不来了并不会决定李四来不来。
start 和 run 之间的区别：
start是真正上创建了一个进程（从系统这里创建的），线程是独立的执行流。
run只是描述了线程要干的活是什么，如果直接在main中调用 run 。
此时没有创建新线程，全是main线程一个人干活。
2.java中创建线程的方法
2.1 继承Thread 重写run
第一种方法就是前面介绍的方法。
2.2 实现Runnable 接口
package thread;
//Runnable 的作用是描述一个要“执行的任务”，run方法就是任务的执行细节
class MyRunnable implements Runnable {
@Override
public void run() {
System.out.println("hello 张三");
}
}
public class ThreadDemo2 {
public static void main(String[] args) {
//这只是描述了任务
Runnable runnable = new MyRunnable();
//把任务交给线程来执行
Thread thread = new Thread(runnable);
thread.start();
}
}
如果未来要更改代码，不用多线程，
而是使用多进程，或者线程池、协程…此时的代码改动比较小。
2.3 使用匿名的内部类，继承 Thread
package thread;
public class ThreadDemo3 {
public static void main(String[] args) {
Thread thread = new Thread() {
@Override
public void run() {
System.out.println("haha");
}
};
thread.start();
}
}
上面方法先是创建了一个Thread的子类（子类没有名字），所以才叫做匿名。
然后是创建了子类的实例，并且让thread引用指向该实例。
2.4 使用匿名类。继承 Runnable
package thread;
public class ThreadDemo4 {
public static void main(String[] args) {
Thread thread = new Thread(new Runnable() {
@Override
public void run() {
System.out.println("hehehehe");
}
});
thread.start();
}
}
这个写法本质和2相同。
只不过是把实现 Runnable 任务交给了匿名内部类的语法。
此处是创建了一个类，实现 Runnable ，同时创建了类的实例，并且传给 Thread 的构造方法。
2.5 使用 Lambda 表达式（最简答、最推荐）
package thread;
public class ThreadDemo5 {
public static void main(String[] args) {
Thread thread = new Thread(() -> {
System.out.println("hellohello");
});
thread.start();
}
}
把任务用 Lambda 表达式来描述
直接把 Lambda 传给 Thread 构造方法。
