线程与进程

进程：

​ 是指一个内存中运行的应用程序，每个进程都有一个独立的内存空间，一个应用程序可以同时运行多个进程；进程也是程序的一次执行过程，是系统运行程序的基本单位；系统运行一个程序即是一个进程从创建、运行到消亡的过程。

线程：

​ 进程内部的一个独立执行单元；一个进程可以同时并发地运行多个线程，可以理解为一个进程便相当于一个单 CPU 操作系统，而线程便是这个系统中运行的多个任务。

进程与线程的区别：

​ 进程：有独立的内存空间，进程中的数据存放空间(堆空间和栈空间)是独立的，至少有一个线程。

​ 线程：堆空间是共享的，栈空间是独立的，线程消耗的资源比进程小的多。

注意：

因为一个进程中的多个线程是并发运行的，那么从微观角度看也是有先后顺序的，哪个线程执行完全取决于CPU 的调度，程序员是不能完全控制的(可以设置线程优先级)。而这也就造成的多线程的随机性。

Java 程序的进程里面至少包含两个线程，主线程也就是 main()方法线程，另外一个是垃圾回收机制线程。每当使用 java 命令执行一个类时，实际上都会启动一个 JVM，每一个 JVM 实际上就是在操作系统中启动了一个线程，java 本身具备了垃圾的收集机制，所以在 Java 运行时至少会启动两个线程。

由于创建一个线程的开销比创建一个进程的开销小的多，那么我们在开发多任务运行的时候，通常考虑创建多线程，而不是创建多进程。

多线程

多线程技术可以更好地利用系统资源。主要优势在于充分利用了CPU的空闲时间片，用尽可能少的时间来对用户的要求做出响应，使得进程的整体运行效率得到较大提高，同时增强了应用程序的灵活性。

​ 更为重要的是，由于同一进程的所有线程共享同一内存，所以不需要特殊的数据传送机制，不需要建立共享存储区或共享文件，从而使得不同任务之间的协调操作与运行、数据的交互、资源的分配等问题更加易于解决。

创建多线程的五种方式

1.继承Thread类

Thread类本质上是实现了Runnable接口的一个实例，代表一个线程的实例。

启动线程的唯一方法就是通过Thread类的start()实例方法。

start()方法是Java的native方法，它将启动一个新线程，并执行run()方法。

这种方法实现多线程比较简单，通过自己创建的类直接继承Thread，并重写run()方法，就可以启动新线程并执行自己定义的run()方法。

优点：代码比较简单

缺点：该类无法继承其他类

1 public classThreadDemo1 {2

3 public static voidmain(String[] args) {4 ThreadDemo t1 = newThreadDemo();5 t1.setName("线程1");6 t1.start();7 ThreadDemo t2 = newThreadDemo();8 t2.setName("线程2");9 t2.start();10 }11

12 }13

14 class ThreadDemo extendsThread{15 @Override16 public voidrun() {17 for (int i = 1; i <= 10; i++) {18 System.out.println(Thread.currentThread().getName()+":"+i);19 }20 }21 }

2.实现Runnable接口

Java的继承属于单继承，如果一个类继承了其他的一个类就无法继承Thread类。但是一个类继承一个类的同时，可以实现多个接口。

优点：继承其他类，统一实现该接口的实例可以共享资源。

缺点：代码比较复杂。

1 public classThreadDemo2 {2

3 public static voidmain(String[] args) {4 MyThread myThread= newMyThread();5 Thread t1 = new Thread(myThread, "线程1");6 t1.start();7 Thread t2 = new Thread(myThread, "线程2");8 t2.start();9 }10

11 }12

13 class MyThread implementsRunnable{14 @Override15 public voidrun() {16 for (int i = 1; i <= 10; i++) {17 System.out.println(Thread.currentThread().getName()+":"+i);18 }19 }20 }

3.实现Callable接口

实现Callable接口和实现Runnable接口的方法基本相同，不过Callable接口中的call()方法有返回值，Runnable接口中的call()方法没有返回值。

1 public classThreadDemo3 {2

3 public static void main(String[] args) throwsExecutionException, InterruptedException {4 Callable myCallable = new MyCallable();5 //使用FutureTask类包装Callable对象,该FutureTask对象封装了Callable对象的call()方法的返回值

6 FutureTask futureTask = new FutureTask(myCallable);7 Thread t1 = new Thread(futureTask, "线程1");8 t1.start();9 System.out.println(futureTask.get());10 }11 }12

13

14 class MyCallable implements Callable{15

16 @Override17 public Object call() throwsException {18 for (int i = 1; i <= 10; i++) {19 System.out.println(i);20 }21 return Thread.currentThread().getName()+"执行完毕";22 }23 }

4.线程池

线程池，其实就是一个容纳多个线程的容器，其中的线程可以重复使用，省去了频繁创建线程对象的操作，避免了频繁创建线程的资源消耗。

Executor类：提供了一系列工厂方法用于创建线程池，返回的线程池都实现了ExecutorService接口。

Java通过Executors提供四种线程池，分别为：

newCachedThreadPool创建一个可缓存线程池，如果线程池长度超过处理需要，可灵活回收空闲线程，若无可回收，则新建线程。

newFixedThreadPool 创建一个定长线程池，可控制线程最大并发数，超出的线程会在队列中等待。

newScheduledThreadPool 创建一个定长线程池，支持定时及周期性任务执行。

newSingleThreadExecutor 创建一个单线程化的线程池，它只会用唯一的工作线程来执行任务，保证所有任务按照指定顺序(FIFO, LIFO, 优先级)执行。

ExecutorService提供了sumbit()方法，传递一个Callable或Runnable，将线程放进线程池中，并执行。

优点：实现自动化装配，易于管理，循环利用资源。

1 public classThreadDemo4 {2

3 public static voidmain(String[] args) {4 ExecutorService pool = Executors.newFixedThreadPool(2);5 //将线程放入线程池中并执行

6 Future> submit = pool.submit(newMyRunnableThread());7 pool.submit(newMyRunnableThread());8 //关闭线程池

9 pool.shutdown();10 }11

12 }13

14 class MyRunnableThread implementsRunnable {15 @Override16 public voidrun() {17 for (int i = 1; i <=10 ; i++) {18 System.out.println(Thread.currentThread().getName()+":"+i);19 }20 }21 }

5.Timer类和TimerTask类

在这种实现方式中，Timer类实现的是类似定时任务的功能，也就是定时或者每隔一定时间触发一次线程。

Timer类本身实现的就是一个线程，只是这个线程是用来调用其他线程。

TimerTask类实现了Runnable接口，具备了多线程的能力。

在这种实现方式中，通过继承TimerTask使该类获得多线程的能力，重写run()方法，然后通过Timer类启动线程。

在实际使用时，一个Timer可以启动任意多个TimerTask实现的线程，但是多个线程之间会存在阻塞。所以如果多个线程之间如果需要完全独立运行的话，

最好还是一个Timer启动一个TimerTask实现。

1 public classThreadDemo5 {2

3 public static voidmain(String[] args) {4 Timer timer = newTimer();5 MyTimerTask myTimerTask1 = new MyTimerTask("线程1");6 MyTimerTask myTimerTask2 = new MyTimerTask("线程2");7 //启动线程

8 timer.schedule(myTimerTask1,0);9 timer.schedule(myTimerTask2,0);10 }11

12 }13

14 class MyTimerTask extendsTimerTask{15 privateString TimerTaskName;16

17 publicMyTimerTask(String TimerTaskName) {18 this.TimerTaskName=TimerTaskName;19 }20

21 @Override22 public voidrun() {23 for (int i = 1; i <=10 ; i++) {24 System.out.println(TimerTaskName+":"+i);25 }26 }27 }