进程与线程
简单介绍下基础概念
进程：在内存中执行的应用程序
线程：进程中最小的执行单元，作用是负责当前进程中程序的运行。一个进程中至少有一个线程，一个进程还可以有多个线程，这样的应用程序就称之为多线程程序
下面介绍下创建多线程的几种方式
一、通过继承Thread类来实现
- 定义一个类,继承Thread
- 重写run方法,在run方法中设置线程任务(所谓的线程任务指的是此线程要干的具体的事儿,具体执行的代码)
public class MyThread extends Thread{
@Override
public void run() {
for (int i = 0; i < 20; i++) {
System.out.println("我的线程执行了"+i);
}
}
}
- 创建自定义线程类的对象
- 调用Thread中的start方法,开启线程,jvm自动调用run方法
public class Test {
public static void main(String[] args) {
MyThread t1 = new MyThread();//创建线程对象
//调用start方法,开启线程,jvm自动调用run方法
t1.start();
for (int i = 0; i < 10; i++) {
System.out.println("main线程执行了"+i);
}
}
}
二、实现Runnable接口
- 创建类，实现Runnable接口
- 重写run方法，设置线程任务
public class MyRunnable implements Runnable{
@Override
public void run() {
for (int i = 0; i < 10; i++) {
System.out.println(Thread.currentThread().getName()+"执行了"+i);
}
}
}
- 利用Thread类的构造方法：Thread(Runnable target)，创建Thread对象(线程对象)，将自定义的类当参数传递到Thread构造中，这一步是让我们自己定义的类成为一个真正的线程类对象
- 调用Thread中的start方法,开启线程,jvm自动调用run方法
public class Test {
public static void main(String[] args) {
MyRunnable myRunnable = new MyRunnable();
Thread t1 = new Thread(myRunnable); //Thread(Runnable target)
t1.start();//调用Thread中的start方法,开启线程
for (int i = 0; i < 10; i++) {
System.out.println(Thread.currentThread().getName()+"执行了"+i);
}
}
}
实现Runnable接口的基础上通过匿名内部类创建多线程
Thread(Runnable target, String name) :name指的是给线程设置名字
public class Test {
public static void main(String[] args) {
new Thread(new Runnable() {
@Override
public void run() {
for (int i = 0; i < 10; i++) {
System.out.println(Thread.currentThread().getName()+"执行了"+i);
}
}
},"哈哈").start();
new Thread(new Runnable() {
@Override
public void run() {
for (int i = 0; i < 10; i++) {
System.out.println(Thread.currentThread().getName()+"执行了"+i);
}
}
},"你好").start();
}
}
执行结果如下
继承Thread类和实现Runnable接口两种实现多线程的方式区别
- 继承Thread类方式，只支持单继承，有继承的局限性
- 实现Runnable接口方式：没有继承的局限性，可以解决需要继承其它类的需求
MyThread extends 其它类 implements Runnable
三、实现Callable接口
Callable是一个接口，类似于Runnable，其中的方法call() 类似于Runnable接口的run()方法是用来设置线程任务的
call()和run()的区别：call()方法有返回值，而且异常可以throws。run()方法没有返回值，而且有异常不可以throws。
获取call()方法的返回值
FutureTask 实现了一个接口：Future
FutureTask中有一个方法get() 用来获取call方法的返回值。
public class MyCallable implements Callable<String> {
@Override
public String call() throws Exception {
for (int i = 0; i < 10; i++) {
System.out.println(Thread.currentThread().getName()+"执行了"+i);
}
return "call方法返回值";
}
}
public class Test {
public static void main(String[] args) throws ExecutionException, InterruptedException {
MyCallable myCallable = new MyCallable();
FutureTask<String> futureTask = new FutureTask<>(myCallable);
Thread t1 = new Thread(futureTask);//创建Thread对象-> Thread(Runnable target)
t1.start();
for (int i = 0; i < 10; i++) {
System.out.println("main线程执行了"+i);
}
System.out.println(futureTask.get());//调用get方法获取call方法返回值
}
}
运行结果如下：
四、线程池的方式创建多线程
线程池（ThreadPool）是一种基于池化思想管理和使用线程的机制：它是将多个线程预先存储在一个“池子”内，当有任务出现时可以避免重新创建和销毁线程所带来性能开销，只需要从“池子”内取出相应的线程执行对应的任务即可。解决了之前每来一个线程任务，就需要创建一个线程对象去执行，用完还要销毁线程对象。线程任务多了，就需要频繁创建线程对象和销毁线程对象耗费内存资源多的问题。
- 创建获取线程池对象用Executors中的静态方法，其中的参数
nThreads指定了线程池中最多创建的线程对象条数。返回值ExecutorService是线程池，用来管理线程对象。
static ExecutorService newFixedThreadPool(int nThreads)
-
ExecutorService中的submit方法用于执行线程任务。返回值用Future接收。
-
void shutdown() 有序关闭线程池，其中先前提交的任务将被执行，但不会接受任何新任务。
public class MyCallable implements Callable<String> {
@Override
public String call() throws Exception {
return "call方法返回值";
}
}
public class Test {
public static void main(String[] args) throws ExecutionException, InterruptedException {
ExecutorService es = Executors.newFixedThreadPool(2);
Future<String> future = es.submit(new MyCallable());
System.out.println(future.get());
es.shutdown(); //有序关闭线程池
}
}
执行结果如下，如果注释掉了es.shutdown()可以看到程序并没有结束，线程池等的新的线程任务到来。
具体可以看看这篇文章
