1 多线程
1.1 介绍
进程: 进程指正在运行的程序。确切的来说,当一个程序进入内存运行,即变成一个进程,进程是处于运行过程中的程序,并且具有一定独立功能。
线程: 线程是进程中的一个执行单元,负责当前进程中程序的执行,一个进程中至少有一个线程。一个进程中是可以有多个线程的,这个应用程序也可以称之为多线程程序。
一个程序运行后至少有一个进程,一个进程中可以包含多个线程。
多线程:一个程序中有多个线程在同时进行。
创建线程的目的:
- 是为了建立程序单独的执行路径,让多部分代码实现同时执行。
- 对于主线程,它的任务定义在main函数中。自定义线程需要执行的任务都定义在run方法中。
1.2 程序运行原理
1)分时调度
所有线程轮流使用 CPU 的使用权,平均分配每个线程占用 CPU 的时间。
2)抢占式调度
优先让优先级高的线程使用 CPU,如果线程的优先级相同,那么会随机选择一个(线程随机性),Java使用的为抢占式调度。
实际上,CPU(中央处理器)使用抢占式调度模式在多个线程间进行着高速的切换。对于CPU的一个核而言,某个时刻,只能执行一个线程,而 CPU的在多个线程间切换速度相对我们的感觉要快,看上去就是在同一时刻运行。
其实,多线程程序并不能提高程序的运行速度,但能够提高程序运行效率,让CPU的使用率更高。
1.3 主线程
JVM启动后,必然有一个执行路径(线程)从main方法开始的,一直执行到main方法结束,这个线程在java中称之为主线程。
1.4 创建线程
1)创建线程方式一:继承Thread类
步骤:
- 定义一个类继承Thread
- 重写run()方法
- 创建子类对象
- 调用start()方法
// 创建自己的线程类
public class MyThread extends Thread {
// 定义指定线程名称的构造方法
public MyThread(String name) {
// 调用父类的构造方法,指定线程的名称
super(name);
}
// 重写run()方法,完成该线程执行的逻辑
@Override
public void run() {
for (int i = 0; i < 50; i++) {
System.out.println(getName() + ": is running..." + i);
}
}
}
// 测试类(主线程)
public class TestSth {
public static void main(String[] args) {
// 1 创建自定义线程对象
MyThread mThread = new MyThread("我的线程");
// 2 开启线程
mThread.start();
// 3 在主方法中执行for循环
for (int i = 0; i < 50; i++) {
System.out.println("主线程。。。");
}
}
}
2)创建线程方式二:实现Runnable接口
步骤:
- 定义类实现Runnable接口
- 覆盖接口中的run()方法
- 创建Thread类的对象
- 将Runnable接口的子类对象作为参数传递给Thread类的构造函数
- 调用Thread类的start()方法开启线程
// 定义类实现Runnable接口
public class MyRunnable implements Runnable {
@Override
public void run() {
for (int i = 0; i < 50; i++) {
System.out.println("我的线程...." + i);
}
}
}
// 测试类(主线程)
public class TestSth {
public static void main(String[] args) {
// 1 创建线程执行目标类对象
Runnable runnable = new MyRunnable();
// 2 将Runnable接口的子类对象作为参数传递给Thread类的构造函数
Thread t1 = new Thread(runnable);
Thread t2 = new Thread(runnable);
// 3 开启线程
t1.start();
t2.start();
// 主线程for循环
for (int i = 0; i < 50; i++) {
System.out.println("主线程...." + i);
}
}
}
1.5 继承Thread和实现Runnable接口区别
- 实现Runnable接口,避免了继承Thread类的单继承局限性。覆盖Runnable接口中的run方法,将线程任务代码定义到run方法中。
- 创建Thread类的对象,只有创建Thread类的对象才可以创建线程。线程任务已被封装到Runnable接口的run方法中,而这个run方法属于Runnable接口的子类对象,所以将这个子类对象作为参数传递给Thread的构造函数,这样,线程对象创建时就可以明确要运行的线程的任务。
1.6 实现Runnable的好处
实现Runnable接口避免了单继承的局限性,所以较为常用。实现Runnable接口的方式,更加的符合面向对象,线程分为两部分,一部分线程对象,一部分线程任务。继承Thread类,线程对象和线程任务耦合在一起。一旦创建Thread类的子类对象,既是线程对象,有又有线程任务。实现runnable接口,将线程任务单独分离出来封装成对象, 类型就是Runnable接口类型。Runnable接口对线程对象和线程任务进行解耦。
1.7 线程的匿名内部类使用
使用线程的内匿名内部类方式,可以方便的实现每个线程执行不同的线程任务操作。
示例:方式一,创建线程对象,直接重写Thread类中的run()方法
public static void main(String[] args) {
// 创建线程对象,直接重写Thread类中的run()方法
new Thread() {
public void run() {
for (int i = 0; i < 50; i++) {
System.out.println(Thread.currentThread().getName() + "..." + i);
}
}
}.start();
// 主线程循环
for (int i = 0; i < 50; i++) {
System.out.println("主线程。。。" + i);
}
}
示例:方式二,实现runnable接口,重写接口中的run()方法
public static void main(String[] args) {
Runnable runnable=new Runnable() {
@Override
public void run() {
for (int i = 0; i < 50; i++) {
System.out.println(Thread.currentThread().getName()+"。。。" + i);
}
}
};
// 启动线程
new Thread(runnable).start();
// 主线程
for (int i = 0; i < 50; i++) {
System.out.println("主线程。。。" + i);
}
}
2 线程池
2.1 介绍
线程池, 其实就是一个容纳多个线程的容器,其中的线程可以反复使用,省去了频繁创建线程对象的操作,无需反复创建线程而消耗过多资源。
为什么要使用线程池?
- 创建和销毁线程花费的时间和消耗的资源大。
- 太多的线程会过度消耗内存而导致系统资源不足。
2.2 使用线程池
1)方式一:Runnable接口
步骤:
- 创建线程池对象
- 创建Runnable接口子类对象
- 提交Runnable接口子类对象
- 关闭线程池
// 创建Runnable接口子类对象
public class MyRunnable implements Runnable {
@Override
public void run() {
System.out.println("我要一个线程。");
try {
Thread.sleep(2000);
} catch (InterruptedException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
System.out.println("线程来了:"+Thread.currentThread().getName());
System.out.println("用完了线程,你回到池里吧");
}
}
// 测试类(主线程)
public static void main(String[] args) {
// 1 创建线程池对象
ExecutorService service=Executors.newFixedThreadPool(2);// 包含2个线程对象
// 2 创建Runnable实例对象
MyRunnable mRunnable=new MyRunnable();
// 3 从线程池中获取线程对象,然后调用run()方法
service.submit(mRunnable);
service.submit(mRunnable);
service.submit(mRunnable);
// 4 关闭线程池
service.shutdown();
}
注意:
- submit()方法调用结束后,程序并不终止,是因为线程池控制了线程的关闭。将使用完的线程又归还到了线程池中。
2)方式二:Callable接口
步骤:
- 创建线程池对象
- 创建Callable接口子类对象
- 提交Callable接口子类对象
- 关闭线程池
// 创建Callable接口子类对象
public class MyCallable implements Callable {
@Override
public Object call() throws Exception {
System.out.println("我要一个线程。。。");
Thread.sleep(2000);
System.out.println("线程来了。。。" + Thread.currentThread().getName());
System.out.println("线程用完了,回到池里吧");
return null;
}
}
// 测试类(主线程)
public static void main(String[] args) {
// 1 创建线程池对象
ExecutorService service=Executors.newFixedThreadPool(2);// 包含2个线程对象
// 2 创建Callable实例对象
MyCallable myCallable=new MyCallable();
// 3 从线程池中获取线程对象,然后调用run()方法
service.submit(myCallable);
service.submit(myCallable);
service.submit(myCallable);
// 4 关闭线程池
service.shutdown();
}