目录
一、简单介绍 Thread类
【1】Thread类中一些常用的方法
【2】编写一个简单多线程程序(入门)
二、Java中创建多线程的方法(重点面试题)
1.继承 Thread 类
2.实现 Runnable 接口,重写 run
3.使用匿名内部类,实现 创建 Thread 子类的方式
4.使用匿名内部类,实现 Runnable 接口的方法
5.lambda 表达式【推荐】
三、简单分析多线程编程提升效率
一、简单介绍 Thread类
线程是操作系统的概念。操作系统给线程的一些相关操作,提供了一系列的API让用户使用(例如 Linux 的 pthread 库)。
这些系统原生的 API 是用 C语言编写的,而Java 为了能够方便使用这些 API, 就把这些 API 给封装成 Java 风格的类。
这个类就是 Java标准库中的 Thread 类
Thread 类可以视为是对操作系统提供的 API 进行了进一步的封装和抽象
【1】Thread类中一些常用的方法
🌑start 方法
调用 start() 方法用来启动一个线程。当我们创建一个线程后,只有调用 start() 方法才能启动,并执行一些任务。
🌒run 方法
run() 方法是不需要用户调用的。run() 方法相当于线程他的本质工作,当线程通过 start() 启动后,线程会自动执行 run() 内的任务。
注意:继承Thread类时,必须重写run方法,在run方法内自定义要执行的任务
🌓sleep 方法
sleep(long ms) //参数为毫秒
sleep(long ms,int nanoseconds)//第一个参数为毫秒,第二个参数为纳秒
sleep() 方法相当于让线程休眠
注意:使用 sleep方法是要处理一下异常!
【2】编写一个简单多线程程序(入门)
如果我们想创建一个线程并让它不断打印 “hello world”的任务。
首先:我们可以自己创建一个线程类(MyThread) 继承 Thread 类
第二步:重写 run() 方法,把我们想要线程执行的任务写入 run() 方法内部,如下
class MyThread extends Thread{@Overridepublic void run() {System.out.println("hello thread!");}
}
第三步:在 main函数中创建名为 MyThread的线程,并调用 start() 方法启动该线程
public class Demo1 {public static void main(String[] args){MyThread myThread = new MyThread();myThread.start();}
}
这样我们就创建了一个线程啦。
在 Java 中,一个 Java 程序相当于一个进程,而 main函数相当于 主线程。我们创建的线程 和 主线程都是属于进程!!
- 每个线程都是一个独立的执行流
- 多个线程之间是 “并发” 执行的
为了方便观察多线程的执行法过程,我们在 main函数 中也写上打印任务,并分别调用 sleep 方法,方便我们观察。
package threading;class MyThread extends Thread{@Overridepublic void run() {while(true){System.out.println("hello thread!");try {Thread.sleep(1000);} catch (InterruptedException e) {throw new RuntimeException(e);}}}
}//多线程创建实例
public class Demo1 {public static void main(String[] args) throws InterruptedException {MyThread myThread = new MyThread();myThread.start();while(true){System.out.println("hello main");Thread.sleep(1000);}}
}
结果如下:
我们会发现 main主线程 和 我们创建的线程是并发执行的(并发+并行),并不是串行执行的。
我们还可以使用 jconsole 命令观察线程
jconsole 命令查找可以查看:使用 jconsole 命令观察线程
二、Java中创建多线程的方法(重点面试题)
1.继承 Thread 类
上述给大家演示的代码就是继承 Thread 类创建线程的方法,这里就不再赘述了。
2.实现 Runnable 接口,重写 run
先创建一个实现 Runnable 接口的类,实例化后作为参数传递给 Thread 构造方法。
class MyRunnable implements Runnable{@Overridepublic void run() {while(true){...}}
}
public class Demo2 {public static void main(String[] args) {MyRunnable runnable = new MyRunnable();Thread t = new Thread(runnable);t.start();while(true){System.out.println("hello main");}}
}
这种方式把 线程要干的活和线程本身分开!把 任务 提取出来,并使用 Runnable 来专门表示“ 线程要完成的工作 ”
把任务提取出来,目的仍然是为了 解耦合 !
前面继承Thread 协防,就把线程要完成的工作,和线程本身,耦合在一起了
假设未来要对这个代码进程调整(不用多线程了,用其他方式),代码改动就比较大
而 Runnable 这种写法,就只是需要把 Runnable 传给其他的实体即可!!
3.使用匿名内部类,实现 创建 Thread 子类的方式
package threading;public class Demo3 {public static void main(String[] args) {Thread t = new Thread(){public void run(){while(true){System.out.println("hello thread");try {Thread.sleep(1000);} catch (InterruptedException e) {throw new RuntimeException(e);}}}};t.start();}
}
4.使用匿名内部类,实现 Runnable 接口的方法
在 Thread 的构造方法的参数里面就地创建了一个匿名内部类
public class Demo4 {public static void main(String[] args) {Thread t = new Thread(new Runnable() {@Overridepublic void run() {while (true) {System.out.println("hello thread");try {Thread.sleep(1000);} catch (InterruptedException e) {throw new RuntimeException(e);}}}});t.start();}
}
匿名内部类的实例,作为构造方法的参数
5.lambda 表达式【推荐】
lambda 本质上是一个 “匿名函数”
语法格式如下:
Thread t = new Thread(()->{//...
});
():内代表函数的形参 {}:代表函数体
-> 特殊语法,表示它是一个 lambda
public class Demo5 {public static void main(String[] args) {Thread t = new Thread(() -> {while(true){System.out.println("hello thread");try {Thread.sleep(1000);} catch (InterruptedException e) {throw new RuntimeException(e);}}});}
}
注意:创建线程并不知道以上五种方式,不过大家知道这些就已经足够了
三、简单分析多线程编程提升效率
观察多线程在一些场合下,并行执行提升的代码运行速度的效率
System.currentTimeMillis():获取当前的时间戳。
serial 串行的完成一下运算,concurrency 使用两个线程并行执行相同操作。
package threading;public class Demo6 {public static final long COUNT = 10_0000_0000L;public static void main(String[] args) throws InterruptedException {serial();concurrency();}// 串行执行任务public static void serial(){// 记录 ms 级别的时间戳long beg = System.currentTimeMillis();long a = 0;for(long i = 0;i < COUNT;i++){a++;}a= 0;for (int i = 0; i < COUNT; i++) {a++;}long end = System.currentTimeMillis();System.out.println("执行的时间间隔" + (end - beg) + " ms");}// 并发执行任务public static void concurrency() throws InterruptedException {long beg = System.currentTimeMillis();Thread t1 = new Thread(() -> {long a = 0;for (int i = 0; i < COUNT; i++) {a++;}});Thread t2 = new Thread(() -> {long a = 0;for (int i = 0; i < COUNT; i++) {a++;}});t1.start();t2.start();t1.join();t2.join();long end = System.currentTimeMillis();System.out.println("执行的时间间隔" + (end - beg) + " ms");}
}
join(): 阻塞等待线程的结束!
在main 中调用 t1.join() 效果就是让 main 线程阻塞,一直到 t1 执行完 run , mian才继续执行!!
由结果可知,在相同运算操作下,并行执行大致能比串行执行快1倍左右。但是并行执行提升代码速度并不是没有代价的,比如运算操作不准确等,这些就需要我们更加深度的学习。