# 进程
是指一个 内存中运行的应用程序,每个进程 都有一个独立的内存空间,一个应用程序可以同时运行多 个进程,进程也是 程序的一次执行过程
,是系统 运行程序的基本单位
系统运行一个程序即是 一个进程从创建、运行 到 消亡的过程
# 线程
进程中的一个执行单元,负责当前进程中程序的执行,一个进程中至少有一个线程,一个进程中是可 以有多个线程的,这个应用程序也可以称之为 多线程程序
# 进程与线程的区别
进程:有独立的内存空间,进程中的数据存放空间(堆空间和栈空间)是独立的,至少有一个线程
线程:堆空间是共享的,栈空间是独立的,线程消耗的资源比进程小的多
Java 使用 java.lang.Thread
类代表线程,所有的线程对象都必须是 Thread 类或其子类的实例
每个线程的作用是 完成一定的任务,实际上就是执行一段程序流即一段顺序执行的代码
Java 使用 线程执行体
来代表这段程序流
start()
方法来启动该线程自定义线程类
/**
* @Author jonath_yh
* @Date 2020-06-30 11:24
* @Version 1.0
**/
public class MyThread extends Thread {
/**
* 定义指定线程名称的构造方法
*
* @param name
*/
public MyThread(String name) {
super(name);
}
/**
* 覆盖 run 方法
*/
@Override
public void run() {
for (int i = 0; i < 1000; i++) {
System.out.println(getName() + "正在执行" + i);
}
}
}
执行线程
public static void main(String[] args) {
MyThread myThread = new MyThread("MyThread");
myThread.start();
for (int i = 0; i < 1000; i++) {
System.out.println("main" + i);
}
}
程序启动运行 main 时候,Java虚拟机启动一个进程,主线程 main 在 main() 调用时候被创建
随着调用 mt的对象的 start
方法,另外一个新的线程也启动了,这样,整个应用就在多线程下运行
方法名 | 描述 |
---|---|
public Thread() | 分配一个新的线程对象 |
public Thread(String name) | 分配一个指定名字的新的线程对象 |
public Thread(Runnable target) | 分配一个带有指定目标新的线程对象 |
public Thread(Runnable target,String name) | 分配一个带有指定目标新的线程对象并指定名字 |
方法名 | 描述 |
---|---|
public String getName() | 获取当前线程名称 |
public void start() | 导致此线程开始执行,Java虚拟机调用此线程的 run 方法 |
public void run() | 此线程要执行的任务在此处定义代码 |
public static void sleep(long millis) | 使当前正在执行的线程以指定的毫秒数暂停(暂时停止执行) |
public static Thread currentThread() | 返回对当前正在执行的线程对象的引用 |
getName
,String getName() 返回该线程的名称/**
* @Author jonath_yh
* @Date 2020-06-30 11:24
* @Version 1.0
**/
public class MyThread extends Thread {
/**
* 定义指定线程名称的构造方法
*
* @param name
*/
public MyThread(String name) {
super(name);
}
/**
* 覆盖 run 方法
*/
@Override
public void run() {
for (int i = 0; i < 1000; i++) {
System.out.println(getName() + "正在执行" + i);
// 1. 可以使用Thread类中的方法getName
String name = getName();
System.out.println(name);// 创建时, 指定了名称,获取的就是指定的名称
// 如果没有指定名称,获取的就是Thread-0
// 2. 可以先获取当前正在执行的线程
Thread currentThread = Thread.currentThread();
System.out.println(currentThread);// Thread[Thread-0,5,main]
String name2 = currentThread.getName();
System.out.println(name2);// Thread-0
}
}
public static void main(String[] args) {
MyThread myThread = new MyThread("MyThread");
myThread.start();
for (int i = 0; i < 1000; i++) {
System.out.println("main" + i);
}
}
}
setName
,void setName(String name) 改变线程名称,使之与参数 name 相同public static void main(String[] args) {
MyThread myThread = new MyThread();
myThread.setName("myThreadName");
myThread.start();
for (int i = 0; i < 1000; i++) {
System.out.println("main" + i);
}
}
/**
* 定义指定线程名称的构造方法
*
* @param name
*/
public MyThread(String name) {
super(name);
}
// 在实例化的时候指定线程名称
MyThread myThread = new MyThread("MyThread");
# public?static?void?sleep(long?millis)
使当前 正在执行的线程 以指定的 毫秒数 暂停
(暂时停止执行)睡醒了,继续执行
/**
* 覆盖 run 方法
*/
@Override
public void run() {
/* 程序在执行第二秒时, 会暂停2秒,2秒后,继续执行后面程序 */
for (int i = 1; i <= 60; i++) {
System.out.println(i);
/* 让程序睡眠1秒钟 1秒=1000毫秒 */
try {
Thread.sleep(2000);
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
多线程 程序的第二种实现方式
方法名 | 描述 |
---|---|
Thread(Runnable target) | 分配新的 Thread 对象 |
Thread(Runnable target, String name) | 分配新的 Thread 对象 |
run方法
,设置线程任务/**
* @Author jonath_yh
* @Date 2020-06-30 11:24
* @Version 1.0
**/
// 1. 创建一个类实现 Runnable 接口
public class RunnableImpl implements Runnable {
// 2. 重写Runnable接口中的run方法,设置线程任务
@Override
public void run() {
// 新线程执行的代码
for (int i = 0; i < 20; i++) {
System.out.println(Thread.currentThread().getName() + "===>" + i);
}
}
public static void main(String[] args) {
// 3.创建Runnable接口的实现类对象
RunnableImpl r = new RunnableImpl();
// 4.创建Thread类对象,构造方法中传递Runnable接口的实现类对象
Thread t = new Thread(r);// 打印20次i
// 5.调用Thread类中的start方法,开启新的线程,执行run方法
t.start();
// 主线程开启新线程之后继续执行的代码
for (int i = 0; i < 20; i++) {
System.out.println(Thread.currentThread().getName() + "===>" + i);
}
}
}
如果一个类继承 Thread,则不适合资源共享,但是如果实现了 Runnable接口的话,则很容易的实现资源共享
# 作用:把子类继承父类,重写父类的方法,创建子类对象,合成一步完成,把实现类实现接口,重写接口库的方法,创建实现类对象,合成一步完成,最终得要子类对象或实现类对象
# 格式
new 父类 / 接口 () {
重写父类/接口中的方法
};
public static void main(String[] args) {
new Thread() { // new 没有名称的类 继承Thread
// 重写run方法,设置线程任务
@Override
public void run() {
for (int i = 0; i < 20; i++) {
System.out.println(Thread.currentThread().getName() + "==>" + i);
}
}
}.start();
}