多线程技术概述

多线程技术概述

一、部分概念

1.线程与进程

1）进程：是指一个内存中运行的应用程序，每个进程都有一个独立的内存空间。
2）线程：是进程中的一个执行路径，共享一个内存空间，线程之间可以自由切换，并发执行。一个进程至少有一个线程，线程实际上是在进程基础之上的一步划分，一个进程启动之后，里面的若干执行路径又可以划分成若干个线程。

2.线程调度

1）.分时调度：所有线程轮流使用CPU的使用权，平均分配每个线程占用CPU的时间。
2）.抢占式调度：优先让高级的线程使用CPU，如果线程的优先级相同，那么会随机选择一个（线程随机性），Java使用的为抢占式调度。CPU使用抢占式调度模式在多个线程之间进行着高速切换。对于CPU的一个核心而言，某个时刻只能执行一个线程，而CPU在多个线程间的切换速度相对我们的感觉要快，看上去就是在同一时刻运行。其实，多线程程序并不能提高程序的运行速度，但能够提高程序运行效率，让CPU的使用率更高

3.同步与异步

1）同步：排队执行，效率低但是安全；
2）异步：同时执行，效率高但是数据不安全。

4.并发与并行

1）并发：指两个或多个事件在同一个时间段内发生；
2）并行：指两个或多个事件在同一时刻发生（同时发生）。

二、Runnable与Callable

1.接口定义

1）Callable

	//Callable接口
    public interface Callable<V> {
        V call() throws Exception;
    }

2）Callable

	//Runnable
    public interface Runnabla {
        public abstract void run();
    }

2.Callable使用步骤

1）编写类实现Callable接口，实现call方法

class XXX implements Callable<T> { 
	@Override 
	public <T> call() throws Exception { 
		return T; 
	} 
} 

2）创建FutureTask对象，并传入第一步编写的Callable类对象

FutureTask<Integer> future = new FutureTask<>(callable);

3）通过Thread.启动线程

new Thread(future).start();

3.Runnable与Callable的相同点

1）都是接口；
2）都可以编写多线程程序；
3）都采用Thread.start()启动线程。

4.Runnable与Callable的不同点

1）Runnable没有返回值，Callable可以返回执行结果；
2）Callable接口的call()允许抛出异常，Runnable的run()不能抛出。

5.Callable获取返回值

Callable接口支持返回执行结果，需要调用FutureTask.get()得到，此方法会阻塞主进程的继续往下执行，如果不调用不会阻塞。

6.实现Runnable与继承Thread相比有以下优势

1）通过创建任务，然后给线程分配的方式来实现的多线程，更适合多个线程同时执行相同任务的情况；
2）可以避免单继承所带来的局限性；
3）任务与线程本身是分离的，提高了程序的健壮性；
4）后续学习的线程池技术，接受Runnable类型的任务，不接受Thread类型的线程。

三、关于线程

1.设置线程的名称

方法一：可以在new的时候传入名称，

new Thread(new MyRunnable(),"线程名称").start();

方法二：获取对象返回值的方式调用setName设置名称

2.获取线程的名称

方法一：使用Thread类中的getName方法直接可以获取本线程的名字
方法二：使用Thread类中currentThread静态方法获取当前正在执行对象的引用，再用对象引用调用getName方法获取本线程名称。

3.线程的休眠

所谓线程的休眠就是让线程的执行速度稍微变得慢一点，可指定休眠时间。

sleep()定义在Thread.java中，sleep()的作用是让当前线程休眠，即当前线程会从“运行状态”进入到“休眠（阻塞）状态”。sleep()会指定休眠时间，线程休眠的时间会≥该指定休眠时间；在线程重新被唤醒时，它会由“阻塞状态”变成“就绪状态”，从而等待CPU的调度执行。

public static void main(String[] args) throws InterruptedException {
    //线程的休眠 sleep
    for (int i = 0;i < 10; i ++){
        System.out.println(i);
        Thread.sleep(1000);//休眠1秒
    }
}

4.线程的中断

一个线程是一个独立的执行路径，它是否应该结束，由其自身决定。

线程的thread.interrupt()方法是中断线程，将该线程的中断状态位设置为true。注意：中断的结果是线程死亡还是等待新的任务或是继续运行至下一步，就取决于这个程序本身。
当调用interrupt方法只是为了告知线程该死亡了，线程内部的处理方式将产生一个异常进入catch代码块，程序员来决定线程是否死亡

//不加return不会自杀
catch (InterruptedException e) {
	System.out.println("发现了中断标记，这个线程自杀");
	return;
 }

另：synchronized在获锁的过程中是不能被中断的，意思是如果产生了死锁，则不可能被中断。

5.守护线程和用户线程

用户线程：当一个进程不包含任何的存活的用户线程时，进行结束；
守护线程：守护用户线程的，当最后一个用户线程结束时，所有守护线程自动死亡。

Thread t1 = new Thread(new MyRunnable());
//设置t1为守护线程
t1.setDaemon(true);
t1.start();

四、线程安全与线程不安全

1.线程安全与线程不安全

线程安全：是指多个线程在执行同一段代码的时候采用加锁机制，使每次的执行结果和单线程执行的结果都是一样的，不存在执行结果的二义性；
线程不安全：不提供加锁机制的保护，有可能出现多个线程先后更改数据造成所得到的数据是脏数据。

2.是什么决定的线程安全问题？

线程安全问题都是由全局变量及静态变量引起的

若每个线程中对全局变量、静态变量只有读操作，而无写操作，一般来说，这个全局变量是安全的；若有多个线程同时执行写操作，一般需要考虑线程同步，否则的话就可能影响线程安全。

3.解决方案

1）同步代码块

synchronized (同步锁){
	//方法体
}

2）同步方法

public synchronized void test(){
	//方法体
}

3）锁机制（Lock）
Java提供的同步代码块的另一种机制，比synchronized关键字更强大也更灵活。这种机制基于Lock接口及其实现类（例如：ReentrantLock）
它比synchronized关键字好的地方：
a.提供了更多的功能，tryLock()方法的实现，这个方法试图获取锁。如果锁已经被其他线程占用，它将返回false并继续往下执行代码；
b.Lock接口允许分离读和写操作，允许多个线程读和一个线程写；
c.具有更好的性能。

public class PrintQueue {
	//fair参数为true表示公平锁
	private final Lock A = new ReentrantLock(true);
	//...
}