多线程编程

进程与线程

进程

• 操作系统中，所有运行的任务通常对应一个进程，进程是处于运行过程中的程序，是系统进行资源分配和调度的一个独立单位；
• 进程在操作系统中是独立存在的实体，其拥有独立的资源与地址空间，进程之间不能直接进行访问；
• 区别于程序概念，进程是一个正在系统中活动的指令集合，具有自己的生命周期与状态，而程序只是一个静态的指令集合；
• 一个CPU在某个时间点只能执行一个进程，CPU不断在进程之间进行轮换执行，CPU执行速度很快，用户通常感觉不到中断。

线程

• 线程是进程的拓展，也被称为轻量级进程，线程的引入使得进程可以同时处理多个任务；
• 一个进程包含多个线程，其共享进程的全部资源，同进程中线程可以很方便的进行通信交互；
• 线程是独立运行的，线程的执行时抢占式的，线程可以并发执行，线程也可随时挂起和运行；
• 线程共享内存容易，线程的创建与资源的分配代价小。

使用多线程

Thread类

java中线程使用Thread类，所有线程对象都必须是Thread类或其子类的实例

package lianbiao;

public class xiancheng extends Thread{
	private int i;
	
	public void run() {
		for (; i < 100; i++) {
			//Thread对象直接调用getName()获取当前线程的名字
			System.out.println(getName() + " " + i);
		}
	}
	
	public static void main(String[] args) {
		for(int i = 0; i < 100; i++) {
			//调用Thread的currentThread()方法获取当前线程
			System.out.println(Thread.currentThread().getName() + " " + i);
			if (i == 20) {
				new xiancheng().start(); //创建并启动第一个线程
				new xiancheng().start(); //创建并启动第二个线程
			}
		}
	}
}

上面启动了三个线程，一个主线程与两个Thread线程
Thread.currentThread() ：返回正在执行的线程对象；
getName()：返回调用该方法的类的名字；

Runnable接口

• 第一步：定义Runnable接口的实现类，并重写该接口的run方法，该run方法同样是线程需要执行的任务

• 第二步：创建Runnable实现类的实例，并以此实例作为Thread的target来创建Thread对象，该Thread对象才是真正的线程对象

public class SecondThread implements Runnable { //接口实现
     
    private int i;
 
    @Override
    public void run() {
        for(;i<100;i++) {
            System.out.println(Thread.currentThread().getName()+" "+i);
        }
    }
     
    public static void main(String[] args) {
        for(int i=0;i<100;i++) {
            System.out.println(Thread.currentThread().getName()+" "+i);
            if(i==20) {
                SecondThread s1=new SecondThread();
                new Thread(s1,"新线程1").start();;
                new Thread(s1,"新线程2").start();
            }
        }
    }
}

使用Callable和Future创建线程

细心的读者会发现，上面创建线程的两种方法。继承Thread和实现Runnable接口中的run都是没有返回值的。于是从Java5开始，Java提供了Callable接口，该接口是Runnable接口的增强版。Callable接口提供了一个call()方法可以作为线程执行体，但call()方法比run()方法功能更强大。

创建并启动有返回值的线程的步骤如下：

第一步：创建 Callable接口的实现类，并实现call()方法，该call()方法将作为线程执行体，且该call()方法有返回值，再创建 Callable实现类的实例。从Java8开始，可以直接使用 Lambda表达式创建 Callable对象

第二步：使用FutureTask类来包装Callable对象，该FutureTask对象封装了该Callable对象的call方法的返回值

第三步：使用FutureTask对象作为Thread对象的target创建并启动新线程

第四步：通过FutureTask的get()方法获得子线程执行结束后的返回值

import java.util.concurrent.Callable;
import java.util.concurrent.FutureTask;
 
public class ThirdThread {
     
    public static void main(String[] args) {
        //ThirdThread rt=new ThirdThread();
        FutureTask<Integer> task=new FutureTask<Integer>((Callable<Integer>)()->{
            int i=0;
            for(;i<100;i++) {
                System.out.println(Thread.currentThread().getName()+"的循环变量i"+i);
            }
            return i;
        }) ;
         
        for(int i=0;i<100;i++) {
            System.out.println(Thread.currentThread().getName()+"的循环变量i为"+i);
            if(i==20) {
                new Thread(task,"有返回值的线程").start();;
            }
        }
        try {
            System.out.println("子线程的返回值"+task.get());
        }catch(Exception e) {
            e.printStackTrace();
        }
    }
 
}

创建线程的三种方式的对比

采用Runnable、Callable接口的方式创建多线程的优缺点：
优点：
1、线程类只是实现了 Runnable接口或 Callable接口，还可以继承其他类
2、在这种方式下，多个线程可以共享同一个 target对象，所以非常适合多个相同线程来处理同一份资源的情况，从而可以将CPU、代码和数据分开，形成清晰的模型，较好地体现了面向对象的思想。
缺点：
编程稍稍复杂，如果需要访问当前线程，则必须使用Thread.currentThread()方法。

采用继承 Thread类的方式创建多线程的优缺点：
优点：
编写简单，如果需要访问当前线程，则无须使用 Thread.current Thread()方法，直接使用this即可获得当前线程
缺点：
因为线程已经继承了Thread类，所以不能再继承其他类