线程和线程之间
堆内存和方法区内存是共享的,但是栈内存独立,一个线程一个栈。
假设启动10个线程,或有10个栈空间,每个栈和每个栈互不干扰,各自执行各自的,这就是多线程并发。
启动分支线程两种方式:
方式一:
继承 Thread类,重写run方法(run方法不需要手动调用java虚拟机会自动调用)
class MYThread extends Thread{
@Override
public void run() {
super.run();
}
}
启动一个分支线程
public class TEST {
public static void main(String[] args) {
// 创建一个分支线程对象
MYThread myThread = new MYThread();
myThread.start();
}
}
start() 方法的作用是:启动一个分支线程,在JVM中,开辟一个新的栈空间,这段代码,任务完成之后,瞬间就结束了,这段代码的任务只是为了开启一个新的栈空间,只要新的栈空间开辟出来,start() 方法就结束了,线程就启动成功了。启动成功的线程会自动调用run方法,并且run方法在分支栈底部(压栈)。
run方法在分支栈的栈底部,main方法在主栈的栈底部。run和main是平级的。
方式二:
实现Runnable接口
public class TEST {
public static void main(String[] args) {
// 创建线程对象
Thread thread = new Thread(new MYThread());
// 启动线程
thread.start();
}
}
// 编写一个类,实现Runnable接口,实现run方法
class MYThread implements Runnable{
@Override
public void run() {
System.out.println("1");
}
}
// lambda表达式
public class TEST {
public static void main(String[] args) {
// 创建线程对象 lambad
Thread thread = new Thread(() -> {
int r = 50;
for (int i = 0; i < 10000; i++) {
System.out.println("子线程线程");
}
});
// 启动线程
thread.start();
for (int i = 0; i < 10000; i++) {
System.out.println("main线程");
}
}
}
线程的生命周期
一共分五个状态
新建状态 -> 就绪状态 -> 运行状态 -> 阻塞状态 -> 死亡状态。
线程名字
1、获取线程名字
线程对象.getName()
2、修改线程对象的名字
线程对象.setName()
public class Lv20210810 {
/**
* 获取线程对象
* 获取线程对象的名字
* 修改线程对象
* @param args
*/
public static void main(String[] args) {
MyTread myTread = new MyTread();
System.out.println(myTread.getName()); // 线程对象默认名字为:Thread-0,以此Thread-1 ··· ···
myTread.setName("123"); // 修改线程名字
System.out.println(myTread.getName()); // 123
myTread.start();
}
}
class MyTread extends Thread {
@Override
public void run() {
System.out.println("子线程执行了");
}
}
3、获取当前线程名字
Thread t = Thread.currentThread()
上边代码出现在哪,获取的就是当前线程的对象。
例:出现在main方法中,获取的就是当前主线程的对象,出现在子线程里,获取的就是子线程对象。
public static void main(String[] args) {
System.out.println(Thread.currentThread().getName()); // main
}
public class Lv20210810 {
public static void main(String[] args) {
MyTread myTread = new MyTread();
myTread.start();
}
}
class MyTread extends Thread {
@Override
public void run() {
System.out.println(Thread.currentThread().getName()); // Thread-0
}
}
线程的sleep
static void sleep(long 毫秒)
Thread.sleep(1000)
线程的阻塞状态。
(1)静态方法
(2)参数是毫秒数
(3)作用:让当前线程进入休眠,进入 "阻塞状态",放弃占有的CPU时间片,让给其他线程使用。
// 3秒钟之后才会打印子线程名称
public class Lv20210810
public static void main(String[] args) {
MyTread myTread = new MyTread();
try {
Thread.sleep(3000);
} catch (InterruptedException e) {
e.printStackTrace();
}
myTread.start();
}
}
class MyTread extends Thread {
@Override
public void run() {
System.out.println(Thread.currentThread().getName()); // Thread-0
}
}
面试题:
1、
下边代码会不会阻塞 t线程的执行?
下边考察两个点:
(1)Thread.sleep() 方法在哪里执行,那么当前的线程会阻塞,下边在main方法中执行,那么它会阻塞main方法的执行。
(2)在java中静态变量可以用类来调用,也可以用对象类调用,但是,java中推荐用类名调用以区别实例方法或实例变量。
下边代码执行结果:先执行 "子线程执行",过3秒钟输出 "main方法执行了" 。
public class Lv20210810 {
public static void main(String[] args) {
MyTread t = new MyTread();
t.setName("t");
t.start();
try {
t.sleep(3000);
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println("main方法执行了");
}
}
class MyTread extends Thread {
@Override
public void run() {
System.out.println("子线程执行");
}
}
终止线程休眠
线程对象.interrupt ()
这种终止方式是靠抛出异常来完成的。
下边代码:先输出 "start" ,三秒钟之后抛出异常,在输出 "end"
public class Lv20210810 {
public static void main(String[] args) {
MyTread t = new MyTread();
t.setName("t");
t.start();
try {
Thread.sleep(3000);
} catch (InterruptedException e) {
e.printStackTrace();
}
// 终止名字为t线程的睡眠
t.interrupt();
}
}
class MyTread extends Thread {
@Override
public void run() {
System.out.println("start");
try {
Thread.sleep(1000L * 60 * 60 * 24 * 365) ;
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println("end");
}
}
合理的终止线程执行
加锁的方式
下边代码,三秒钟之后,我们把down改为false,此时会结束掉 myThread线程的执行。
public class Lv20210810 {
public static void main(String[] args) {
MyTread myTread = new MyTread();
myTread.start();
try {
Thread.sleep(3000);
} catch (InterruptedException e) {
e.printStackTrace();
}
myTread.down = false;
}
}
class MyTread extends Thread {
boolean down = true;
@Override
public void run() {
for (int i = 0; i < 10; i++) {
if(down) {
System.out.println(i);
try {
Thread.sleep(1000);
} catch (InterruptedException e) {
e.printStackTrace();
}
}else {
return;
}
}
}
}