本文介绍了线程的基础知识，包括进程与线程的概念，单线程和多线程的差异，以及并发和并行的区别。详细讲解了如何在Java中通过继承Thread类或实现Runnable接口来创建线程，并给出了代码示例。文章强调了直接调用run方法与start方法启动线程的区别，并建议在需要共享资源或避免单继承限制时使用Runnable接口。
目录
线程在开发中非常的重要，我们先来看看，线程相关的概念
线程的相关概念
进程
1.进程是指运行中的程序，比如我们使用QQ，就启动了一个进程，操作系统就会为该进程分配内存空间。当我们使用迅雷，又启动了一个进程，操作系统将为迅雷分配新的内存空间。
2.进程是程序的一次执行过程，或是正在运行的一个程序。是动态过程：有它自身的产生、存在和消亡的过程
线程
什么是线程
1.线程由进程创建的，是进程的一个实体
2.一个进程可以拥有多个线程
单线程多线程
1.单线程：同一个时刻，只允许执行一个线程
2.多线程：同一个时刻，可以执行多个线程，比如：一个qq进程，可以同时打开多个聊天窗口，一个迅雷进程，可以同时下载多个文件
并发和并行
3.并发：同一个时刻，多个任务交替执行，造成一种“貌似同时”的错觉，简单的说，单核cpu实现的多任务就是并发。
4.并行：同一个时刻，多个任务同时执行。多核cpu可以实现并行。
线程基本使用
创建线程的两种方式
1.继承Thread类，重写 run方法
线程应用案例1
1)请编写程序,开启一个线程， 该线程每隔1秒。在控制台输出“你好'
2)对上题改进:当输出80次 你好，结束该线程
3)可以使用JConsole 监控线程执行情况，
代码演示：
注意：不可以直接调用run方法
/* 注意不可以直接去调用run方法，因为如果直接去调用run方法的话，他不会去启动一个 线程，并且会阻塞程序，只有把run方法执行完毕，才会继续执行下面的代码，并且如果直接调用run方法，此时的线程名还是main */
start()方法调用start0()方法后，该线程并不一定会立马执行，只是将线程变成了可运行状态。具体什么时候执行，取决于 CPU，由 CPU统一调度
注意这里我们调用start方法，最后在底层会去调用start0方法，后面会进行源码分析，并且这个run方法是Thread类继承了Runnable接口，实现了Runnable接口中的run方法，并不是Thread类中的run方法
@FunctionalInterface
public interface Runnable {
public abstract void run();
}
package idea.chapter17.threaduse;
/**
* 演示通过继承Thread 类创建线程
*/
public class Thread01 {
public static void main(String[] args) throws InterruptedException {
//创建Cat对象，可以当做线程使用
Cat cat = new Cat();
//源码
/*
(1)
public synchronized void start() {
start0();
}
(2)
//start0() 是本地方法，是JVM调用, 底层是c/c++实现
//真正实现多线程的效果， 是start0(), 而不是 run
private native void start0();
*/
cat.start();//启动线程-> 最终会执行cat的run方法
//cat.run();//run方法就是一个普通的方法, 没有真正的启动一个线程，就会把run方法执行完毕，才向下执行
//如果写成直接写成cat.run()方法那么就是普通的方法不是线程，因此下面这句话在执行时Thread.currentThread().getName()。输出也就是main而不是Thread
//并且会造成堵塞，会先将run()方法执行完毕之后在，继续执行main()方法下面的代码
/*
注意不可以直接去调用run方法，因为如果直接去调用run方法的话，他不会去启动一个 线程，并且会阻塞程序，只有把run方法执行完毕，才会继续执行下面的代码，并且如果直接调用run方法，此时的线程名还是main
*/
//说明: 当main线程启动一个子线程 Thread-0, 主线程不会阻塞, 会继续执行
//这时 主线程和子线程是交替执行..
System.out.println("主线程继续执行" + Thread.currentThread().getName());//名字main
for(int i = 0; i < 60; i++) {
System.out.println("主线程 i=" + i);
//让主线程休眠
Thread.sleep(1000);//可能会有异常，直接抛出也可以使用try catch
}
}
}
//说明
//1. 当一个类继承了 Thread 类， 该类就可以当做线程使用
//2. 我们会重写 run方法，写上自己的业务代码
//3. run方法是 Thread 类 实现了 Runnable 接口的run方法
/*
@Override
public void run() {
if (target != null) {
target.run();
}
}
*/
class Cat extends Thread {
int times = 0;
@Override
public void run() {//重写run方法，写上自己的业务逻辑
while (true) {
//该线程每隔1秒。在控制台输出 你好
System.out.println("你好" + (++times) + " 线程名=" + Thread.currentThread().getName());
//让该线程休眠1秒 ctrl+alt+t
try {
Thread.sleep(1000);
} catch (InterruptedException e) {
e.printStackTrace();
}
if (times == 80) {
break;//当times 到80, 退出while, 这时线程也就退出..
}
}
}
}2.实现Runnable接口，重写 run方法
1.java是单继承的，在某些情况下一个类可能已经继承了某个父类,这时在用继承Thread类方法来创建线程显然不可能了
2.java设计者们提供了另外一个方式创建线程，就是通过实现Runnable接口来创建线程
请编写程序,该程序可以每隔1秒。在控制台输出“hi!”,当输出10次后，自动退出。请使用实现Runnable接口的方式实现。 Thread02.java，这里底层使用了设计模式[代理模式] => 代码模拟 实现Runnable接口 开发线程的机制
代码演示：
注意：
当我们使用实现Runnable接口来实现线程的时候，就不能够，直接调用start方法，需要创建一个Thread，把dog对象放入，这样就可以调用start方法了，切记不要直接调用run方法，这样就不是多线程了
dog.start(); 这里不能调用start
创建了Thread对象，把 dog对象(实现Runnable),放入Thread
package idea.chapter17.threaduse;
/**
* 通过实现接口Runnable
*/
public class Thread02 {
public static void main(String[] args) {
Dog dog = new Dog();
//当我们使用实现Runnable接口来实现线程的时候，就不能够，直接调用start方法，需要创建一个Thread，把dog对象放入，这样就可以调用start方法了，切记不要直接调用run方法，这样就不是多线程了
//dog.start(); 这里不能调用start
//创建了Thread对象，把 dog对象(实现Runnable),放入Thread
Thread thread = new Thread(dog);
thread.start();
Tiger tiger = new Tiger();//实现了 Runnable
//为什么可以把tiger对象放入到ThreadProxy类中，因为tiger对象实现了Runnable接口
ThreadProxy threadProxy = new ThreadProxy(tiger);
threadProxy.start();
}
}
class Animal {
}
class Tiger extends Animal implements Runnable {
@Override
public void run() {
System.out.println("老虎在叫....");
}
}
//线程代理类 , 模拟了一个极简的Thread类
class ThreadProxy implements Runnable {//你可以把Proxy类当做 ThreadProxy
private Runnable target = null;//属性，类型是 Runnable
@Override
public void run() {
if (target != null) {
target.run();//动态绑定（运行类型Tiger）
}
}
//构造器可以接收一个Runnable的对象
public ThreadProxy(Runnable target) {
this.target = target;
}
public void start() {
start0();//这个方法时真正实现多线程方法
}
public void start0() {
run();
}
}
class Dog implements Runnable { //通过实现Runnable接口，开发线程
int count = 0;
@Override
public void run() { //普通方法
while (true) {
System.out.println("小狗在叫..hi" + (++count) + Thread.currentThread().getName());
//休眠1秒
try {
Thread.sleep(1000);
} catch (InterruptedException e) {
e.printStackTrace();
}
if (count == 10) {
break;
}
}
}
}多线程执行
请编写一个程序,创建两个线程,一个线程每隔1秒输出“hello,world”,输出10次，退出，一个线程每隔1秒输出“hi”，输出 5次退出
代码演示：
注意：都是实现Runnable接口的方式来完成
package idea.chapter17.threaduse;
public class Thread03 {
public static void main(String[] args) {
T1 t1 = new T1();
T2 t2 = new T2();
new Thread(t1).start();//启动第一个线程
new Thread(t2).start();//启动第二个线程
//因为main方法中没有什么其他多余的代码，因此在启动完两个线程之后，main线程就直接自动的退出了
}
}
/*
请编写一个程序,创建两个线程,一个线程每隔1秒输出“hello,world”,输出10次，退出，一个线程每隔1秒输出“hi”，输出 5次退出.Thread03.iava
*/
class T1 implements Runnable {
@Override
public void run() {
int count = 0;
//每隔1秒输出 “hello,world”,输出10次
while (true) {
System.out.println("hello word" + (++count));
try {
Thread.sleep(1000);
} catch (InterruptedException e) {
e.printStackTrace();
}
if (count == 10) {
break;
}
}
}
}
class T2 implements Runnable {
@Override
public void run() {
//每隔1秒输出 “hi”,输出5次
int count = 0;
while (true) {
System.out.println("hi" + (++count));
try {
Thread.sleep(1000);
} catch (InterruptedException e) {
e.printStackTrace();
}
if (count == 5) {
break;
}
}
}
}继承Thread vs 实现Runnable的区别
1.从iava的设计来看，通过继承Thread或者实现Runnable接口来创建线程本质上没有区别,从idk帮助文档我们可以看到Thread类本身就实现了Runnable接口实现
Runnable接口方式更加适合多个线程共享一个资源的情况，并且避免了单继承的限制，建议使用Runnable
扫一扫
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
