day32 多线程(上)

多线程(上)"/>

day32 多线程(上)

文章目录

• 相关概念
• code
• • ThreadTest01
  • ThreadTest02 编写一个类，直接继承java.lang.Thread，重写run方法
  • ThreadTest03 实现线程的第二种方法
  • ThreadTest04 采用匿名内部类的方式
  • ThreadTest05 获取线程名字
  • ThreadTest06 sleep方法
  • sleep面试题
  • ThreadTest08 终止线程的睡眠
  • ThreadTest09 强行终止线程的执行
  • ThreadTest10 合理终止线程执行

相关概念

day32课堂笔记

4、多线程

4.1、什么是进程？什么是线程？进程是一个应用程序（1个进程是一个软件）。线程是一个进程中的执行场景/执行单元。一个进程可以启动多个线程。4.2、对于java程序来说，当在DOS命令窗口中输入：java HelloWorld 回车之后。会先启动JVM，而JVM就是一个进程。JVM再启动一个主线程调用main方法。同时再启动一个垃圾回收线程负责看护，回收垃圾。最起码，现在的java程序中至少有两个线程并发，一个是垃圾回收线程，一个是执行main方法的主线程。4.3、进程和线程是什么关系？举个例子阿里巴巴：进程马云：阿里巴巴的一个线程童文红:阿里巴巴的一个线程京东：进程强东：京东的一个线程妹妹：京东的一个线程进程可以看做是现实生活当中的公司。线程可以看做是公司当中的某个员工。注意：进程A和进程B的内存独立不共享。（阿里巴巴和京东资源不会共享的！）魔兽游戏是一个进程酷狗音乐是一个进程这两个进程是独立的，不共享资源。线程A和线程B呢？在java语言中：线程A和线程B，堆内存和方法区内存共享。但是栈内存独立，一个线程一个栈。假设启动10个线程，会有10个栈空间，每个栈和每个栈之间，互不干扰，各自执行各自的，这就是多线程并发。火车站，可以看做是一个进程。火车站中的每一个售票窗口可以看做是一个线程。我在窗口1购票，你可以在窗口2购票，你不需要等我，我也不需要等你。所以多线程并发可以提高效率。java中之所以有多线程机制，目的就是为了提高程序的处理效率。4.4、思考一个问题：使用了多线程机制之后，main方法结束，是不是有可能程序也不会结束。main方法结束只是主线程结束了，主栈空了，其它的栈(线程)可能还在压栈弹栈。4.5、分析一个问题：对于单核的CPU来说，真的可以做到真正的多线程并发吗？对于多核的CPU电脑来说，真正的多线程并发是没问题的。4核CPU表示同一个时间点上，可以真正的有4个进程并发执行。什么是真正的多线程并发？t1线程执行t1的。t2线程执行t2的。t1不会影响t2，t2也不会影响t1。这叫做真正的多线程并发。单核的CPU表示只有一个大脑：不能够做到真正的多线程并发，但是可以做到给人一种“多线程并发”的感觉。对于单核的CPU来说，在某一个时间点上实际上只能处理一件事情，但是由于CPU的处理速度极快，多个线程之间频繁切换执行，跟人来的感觉是：多个事情同时在做！！！！！线程A：播放音乐线程B：运行魔兽游戏线程A和线程B频繁切换执行，人类会感觉音乐一直在播放，游戏一直在运行，给我们的感觉是同时并发的。电影院采用胶卷播放电影，一个胶卷一个胶卷播放速度达到一定程度之后，人类的眼睛产生了错觉，感觉是动画的。这说明人类的反应速度很慢，就像一根钢针扎到手上，到最终感觉到疼，这个过程是需要“很长的”时间的，在这个期间计算机可以进行亿万次的循环。所以计算机的执行速度很快。

5、java语言中，实现线程有两种方式，那两种方式呢？

java支持多线程机制。并且java已经将多线程实现了，我们只需要继承就行了。第一种方式：编写一个类，直接继承java.lang.Thread，重写run方法。// 定义线程类public class MyThread extends Thread{public void run(){}}// 创建线程对象MyThread t = new MyThread();// 启动线程。t.start();第二种方式：编写一个类，实现java.lang.Runnable接口，实现run方法。// 定义一个可运行的类public class MyRunnable implements Runnable {public void run(){}}// 创建线程对象Thread t = new Thread(new MyRunnable());// 启动线程t.start();注意：第二种方式实现接口比较常用，因为一个类实现了接口，它还可以去继承
其它的类，更灵活。

6、关于线程对象的生命周期？
新建状态
就绪状态
运行状态
阻塞状态
死亡状态

code

ThreadTest01

package com.bjpowernode.java.thread;/*
大家分析以下程序，有几个线程，除垃圾回收线程之外。有几个线程？1个线程。（因为程序只有1个栈。）main begin
m1 begin
m2 begin
m3 execute!
m2 over
m1 over
main over一个栈中，自上而下的顺序依次逐行执行！*/
public class ThreadTest01 {public static void main(String[] args) {System.out.println("main begin");m1();System.out.println("main over");}private static void m1() {System.out.println("m1 begin");m2();System.out.println("m1 over");}private static void m2() {System.out.println("m2 begin");m3();System.out.println("m2 over");}private static void m3() {System.out.println("m3 execute!");}
}

ThreadTest02 编写一个类，直接继承java.lang.Thread，重写run方法

package com.bjpowernode.java.thread;
/*
实现线程的第一种方式：编写一个类，直接继承java.lang.Thread，重写run方法。怎么创建线程对象？ new就行了。怎么启动线程呢？ 调用线程对象的start()方法。注意：亘古不变的道理：方法体当中的代码永远都是自上而下的顺序依次逐行执行的。以下程序的输出结果有这样的特点：有先有后。有多有少。这是咋回事？这里画一个问号？？？？？？？？？？？？？？？？？？？？？？？*/
public class ThreadTest02 {public static void main(String[] args) {// 这里是main方法，这里的代码属于主线程，在主栈中运行。// 新建一个分支线程对象MyThread t = new MyThread();// 启动线程//t.run(); // 不会启动线程，不会分配新的分支栈。（这种方式就是单线程。）// start()方法的作用是：启动一个分支线程，在JVM中开辟一个新的栈空间，这段代码任务完成之后，瞬间就结束了。// 这段代码的任务只是为了开启一个新的栈空间，只要新的栈空间开出来，start()方法就结束了。线程就启动成功了。// 启动成功的线程会自动调用run方法，并且run方法在分支栈的栈底部（压栈）。// run方法在分支栈的栈底部，main方法在主栈的栈底部。run和main是平级的。t.start();// 这里的代码还是运行在主线程中。for(int i = 0; i < 1000; i++){System.out.println("主线程--->" + i);}}
}class MyThread extends Thread {@Overridepublic void run() {// 编写程序，这段程序运行在分支线程中（分支栈）。for(int i = 0; i < 1000; i++){System.out.println("分支线程--->" + i);}}
}

ThreadTest03 实现线程的第二种方法

package com.bjpowernode.java.thread;
/*
实现线程的第二种方式，编写一个类实现java.lang.Runnable接口。*/
public class ThreadTest03 {public static void main(String[] args) {// 创建一个可运行的对象//MyRunnable r = new MyRunnable();// 将可运行的对象封装成一个线程对象//Thread t = new Thread(r);Thread t = new Thread(new MyRunnable()); // 合并代码// 启动线程t.start();for(int i = 0; i < 100; i++){System.out.println("主线程--->" + i);}}
}// 这并不是一个线程类，是一个可运行的类。它还不是一个线程。
class MyRunnable implements Runnable {@Overridepublic void run() {for(int i = 0; i < 100; i++){System.out.println("分支线程--->" + i);}}
}

ThreadTest04 采用匿名内部类的方式

package com.bjpowernode.java.thread;/*
采用匿名内部类可以吗？*/
public class ThreadTest04 {public static void main(String[] args) {// 创建线程对象，采用匿名内部类方式。// 这是通过一个没有名字的类，new出来的对象。Thread t = new Thread(new Runnable(){@Overridepublic void run() {for(int i = 0; i < 100; i++){System.out.println("t线程---> " + i);}}});// 启动线程t.start();for(int i = 0; i < 100; i++){System.out.println("main线程---> " + i);}}
}

ThreadTest05 获取线程名字

package com.bjpowernode.java.thread;
/*
1、怎么获取当前线程对象？Thread t = Thread.currentThread();返回值t就是当前线程。2、获取线程对象的名字String name = 线程对象.getName();3、修改线程对象的名字线程对象.setName("线程名字");4、当线程没有设置名字的时候，默认的名字有什么规律？（了解一下）Thread-0Thread-1Thread-2Thread-3.....*/
public class ThreadTest05 {public void doSome(){// 这样就不行了//this.getName();//super.getName();// 但是这样可以String name = Thread.currentThread().getName();System.out.println("------->" + name);}public static void main(String[] args) {ThreadTest05 tt = new ThreadTest05();tt.doSome();//currentThread就是当前线程对象// 这个代码出现在main方法当中，所以当前线程就是主线程。Thread currentThread = Thread.currentThread();System.out.println(currentThread.getName()); //main// 创建线程对象MyThread2 t = new MyThread2();// 设置线程的名字t.setName("t1");// 获取线程的名字String tName = t.getName();System.out.println(tName); //Thread-0MyThread2 t2 = new MyThread2();t2.setName("t2");System.out.println(t2.getName()); //Thread-1\t2.start();// 启动线程t.start();}
}class MyThread2 extends Thread {public void run(){for(int i = 0; i < 100; i++){// currentThread就是当前线程对象。当前线程是谁呢？// 当t1线程执行run方法，那么这个当前线程就是t1// 当t2线程执行run方法，那么这个当前线程就是t2Thread currentThread = Thread.currentThread();System.out.println(currentThread.getName() + "-->" + i);//System.out.println(super.getName() + "-->" + i);//System.out.println(this.getName() + "-->" + i);}}
}

ThreadTest06 sleep方法

package com.bjpowernode.java.thread;
/*
关于线程的sleep方法：static void sleep(long millis)1、静态方法：Thread.sleep(1000);2、参数是毫秒3、作用：让当前线程进入休眠，进入“阻塞状态”，放弃占有CPU时间片，让给其它线程使用。这行代码出现在A线程中，A线程就会进入休眠。这行代码出现在B线程中，B线程就会进入休眠。4、Thread.sleep()方法，可以做到这种效果：间隔特定的时间，去执行一段特定的代码，每隔多久执行一次。*/
public class ThreadTest06 {public static void main(String[] args) {// 让当前线程进入休眠，睡眠5秒// 当前线程是主线程！！！/*try {Thread.sleep(1000 * 5);} catch (InterruptedException e) {e.printStackTrace();}*/// 5秒之后执行这里的代码//System.out.println("hello world!");for(int i = 0; i < 10; i++){System.out.println(Thread.currentThread().getName() + "--->" + i);// 睡眠1秒try {Thread.sleep(1000);} catch (InterruptedException e) {e.printStackTrace();}}}
}

sleep面试题

package com.bjpowernode.java.thread;
/*
关于Thread.sleep()方法的一个面试题：*/
public class ThreadTest07 {public static void main(String[] args) {// 创建线程对象Thread t = new MyThread3();t.setName("t");t.start();// 调用sleep方法try {// 问题：这行代码会让线程t进入休眠状态吗？t.sleep(1000 * 5); // 在执行的时候还是会转换成：Thread.sleep(1000 * 5);// 这行代码的作用是：让当前线程进入休眠，也就是说main线程进入休眠。// 这样代码出现在main方法中，main线程睡眠。} catch (InterruptedException e) {e.printStackTrace();}// 5秒之后这里才会执行。System.out.println("hello World!");}
}class MyThread3 extends Thread {public void run(){for(int i = 0; i < 10000; i++){System.out.println(Thread.currentThread().getName() + "--->" + i);}}
}

ThreadTest08 终止线程的睡眠

package com.bjpowernode.java.thread;
/*
sleep睡眠太久了，如果希望半道上醒来，你应该怎么办？也就是说怎么叫醒一个正在睡眠的线程？？注意：这个不是终断线程的执行，是终止线程的睡眠。*/
public class ThreadTest08 {public static void main(String[] args) {Thread t = new Thread(new MyRunnable2());t.setName("t");t.start();// 希望5秒之后，t线程醒来（5秒之后主线程手里的活儿干完了。）try {Thread.sleep(1000 * 5);} catch (InterruptedException e) {e.printStackTrace();}// 终断t线程的睡眠（这种终断睡眠的方式依靠了java的异常处理机制。）t.interrupt(); // 干扰，一盆冷水过去！}
}class MyRunnable2 implements Runnable {// 重点：run()当中的异常不能throws，只能try catch// 因为run()方法在父类中没有抛出任何异常，子类不能比父类抛出更多的异常。@Overridepublic void run() {System.out.println(Thread.currentThread().getName() + "---> begin");try {// 睡眠1年Thread.sleep(1000 * 60 * 60 * 24 * 365);} catch (InterruptedException e) {// 打印异常信息//e.printStackTrace();}//1年之后才会执行这里System.out.println(Thread.currentThread().getName() + "---> end");// 调用doOther//doOther();}// 其它方法可以throws/*public void doOther() throws Exception{}*/
}

ThreadTest09 强行终止线程的执行

package com.bjpowernode.java.thread;
/*
在java中怎么强行终止一个线程的执行。这种方式存在很大的缺点：容易丢失数据。因为这种方式是直接将线程杀死了，线程没有保存的数据将会丢失。不建议使用。*/
public class ThreadTest09 {public static void main(String[] args) {Thread t = new Thread(new MyRunnable3());t.setName("t");t.start();// 模拟5秒try {Thread.sleep(1000 * 5);} catch (InterruptedException e) {e.printStackTrace();}// 5秒之后强行终止t线程t.stop(); // 已过时（不建议使用。）}
}class MyRunnable3 implements Runnable {@Overridepublic void run() {for(int i = 0; i < 10; i++){System.out.println(Thread.currentThread().getName() + "--->" + i);try {Thread.sleep(1000);} catch (InterruptedException e) {e.printStackTrace();}}}
}

ThreadTest10 合理终止线程执行

package com.bjpowernode.java.thread;
/*
怎么合理的终止一个线程的执行。这种方式是很常用的。*/
public class ThreadTest10 {public static void main(String[] args) {MyRunable4 r = new MyRunable4();Thread t = new Thread(r);t.setName("t");t.start();// 模拟5秒try {Thread.sleep(5000);} catch (InterruptedException e) {e.printStackTrace();}// 终止线程// 你想要什么时候终止t的执行，那么你把标记修改为false，就结束了。r.run = false;}
}class MyRunable4 implements Runnable {// 打一个布尔标记boolean run = true;@Overridepublic void run() {for (int i = 0; i < 10; i++){if(run){System.out.println(Thread.currentThread().getName() + "--->" + i);try {Thread.sleep(1000);} catch (InterruptedException e) {e.printStackTrace();}}else{// return就结束了，你在结束之前还有什么没保存的。// 在这里可以保存呀。//save....//终止当前线程return;}}}
}