Java多线程(二)

创建线程的四种方式

1.继承Thread类
2.实现Runnable接口
3.实现Callable接口
4.使用Executors工具类创建线程池

继承Thread类
步骤:
1.定义一个Thread类的子类，重写run方法，将相关逻辑实现，run()方法就是线程要执行的业务逻辑方法
2.创建自定义的线程子类对象
3.调用子类实例的start()方法来启动线程
ex:

public class MyThread extends Thread{
	@override
	public void run(){
		S.o.p(Thread.currentThread().getName+"run方法正在执行");
	}
}
public class ThreadTest{
	public static void main(String[] args){
		MyThread mythread=new MyThread();
		mythread.start();
		S.o.p(Thread.currentThread().getName()+"main()方法执行结束");
	}
}

结果:
main main()方法执行结束
Thread-0 run()方法正在执行

实现Runnable接口
步骤:
1.定义Runnable接口实现类MyRunnable,并重写run()方法
2.创建MyRunnable实例myrunnable，以myrunnable作为target创建Thread对象，该Thread对象才是真正的线程对象
ex:

public class MyRunnable implements Runnable{
	@override
	public void run(){
		S.o.p(Thread.currentThread().getName()+"run()方法执行中");
	}
}
public class RunnableTest{
	public static void main(String[] args){
		MyRunnable myrunnable=new MyRunnable();
		Thread thread=new Thread(myrunnable);
		thread.start();
		S.o.p(Thread.currentThread().getName()+"main()方法执行完成");
	}
}

结果:
main main()方法执行完成
Thread-0 run()方法执行中

实现Callable接口
步骤:
1.创建实现Callable接口的类MyCallable,并重写call方法
2.以MyCallable为参数创建FutureTask对象
3.将FutureTask作为参数创建Thread对象
4.调用线程对象的start()方法
ex:

public class MyCallable implements Callable{
	@override
	public Integer call(){
		S.o.p(Thread.currentThread().getName()+"call()方法执行中...");
		return 1;
	}
}
public class CallableTest{
	public static void main(String[] args){
		FutureTask<Integer>futureTask=new FutureTask<Integer>(new MyCallable());
		Thread thread=new Thread(futureTask);
		thread.start();
	}
	try{
		Thread.sleep(1000);
		S.o.p("返回结果"+futureTask.get());
	}catch(InterruptedException e){
		e.printStackTrace();
	}catch(ExecutionException e){
		e.printStackTrace();
	}
	S.o.p(Thread.currentThread().getName()+"main方法执行完成");
}

结果:
Thread-0 call()方法执行中…
返回结果1
main main()方法执行完成

使用Executors工具类创建线程池
Executors提供了一系列工厂方法用于创建线程池，返回的线程池都实现了ExecutorService接口
线程池主要有:
newFixedThreadPool
newCachedThreadPool
newSingleThreadExecutor
newScheduledThreadPool

ex:

public class MyRunnable extends Runnable{
	@Override
	public void run(){
		S.o.p(Thread.currentThread().getName()+"run()方法执行中");
	}
}
public class SingleThreadExecutorTest{
	public static void main(String[] args){
		ExecutorService executorService=Executors.newSingleThreadExecutor();
		MyRunnable runnable=new MyRunnable();
		for(i=0;i<5;i++){
			executorService.execute(runnable);
		}
		S.o.p("线程任务开始执行");
		executorService.shutdown();
	}
}

ex:

结果:
线程任务开始执行
pool-1-thread-1 is runnung…
pool-1-thread-1 is runnung…
pool-1-thread-1 is runnung…
pool-1-thread-1 is runnung…
pool-1-thread-1 is runnung…

runnable和callable有什么区别
相同点:
都是接口
都可以编写多线程代码
都采用Thread.start()启动线程

主要区别
1.Runnable接口run方法无返回值
2.Callable接口call方法有返回值，是个泛型，和Future、FutureTask配合可以用来获取异步执行的结果
3.Runnable接口run方法只能抛出运行时异常，且无法捕获处理
4.Callable接口call方法允许抛出异常，可以获取异常信息

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

线程的run()和start()有什么区别
每个线程都是通过某个特定Thread对象所对应的run()方法来完成其操作的，run()方法称为线程体。通过调用Thread类的start()方法来启动一个线程。
start()方法用于启动线程，run()方法用于执行线程的运行代码，run()可以重复调用，而start()只能调用一次

start()方法来启动线程，真正实现了多线程运行。调用start()方法无需等待run方法体代码执行完毕，可以直接继续执行其他代码。
此时线程处于就绪状态，并没有运行。然后通过此Thread类调用run()来完成其运行状态，run()方法运行结束，此线程终止。然后CPU再调度其它线程。

run()方法是在本线程里的，只是线程里的一个函数，而不是多线程，如果直接调用run()，其实就相当于调用了一个普通函数，直接调用run()方法必须等待run()方法执行完成后才能执行其他代码，所以执行路径还是只有一条，根本没有多线程特征，所以在多线程执行时要使用start()方法而不是run()方法

为什么我们调用start()方法时会执行run()方法，为什么不能直接调用run()方法?
new一个Thread，线程进入了新建状态。调用start()方法，会启动一个线程并使线程进入就绪状态，当分配到时间片后可以开始运行。
start()会执行线程的相应准备工作，然后自动执行run()方法的内容，真正实现多线程

而直接执行run()方法，会把run()方法当成一个普通方法去执行，并不会在某个线程中执行，这并不是多线程工作。

总结:
1.调用start方法可以启动线程并使线程进入就绪状态，此时执行完start方法后，不需要等待run方法执行完，就可以继续执行后面的程序。
2.而run方法只是thread的一个普通方法调用，还是在主线程里执行，如果直接调用run方法，只是把run方法当普通函数调用，且需要等待run方法全部执行完，才可以执行后面的代码，并不是多线程操作。

什么是Callable和Future
Callable接口类似于Runnable接口，但Runnable不会返回结果和抛出异常，而Callable被线程执行后可以返回值，且这个值可以被Future拿到，也就是说Future可以拿到异步执行任务的返回值

Future接口表示异步任务，是一个可能还没有完成的异步任务的结果。所以说Callable用于产生结果，Future用于获取结果

什么是FutureTask
FutureTask表示一个异步运算的任务
FutureTask里可以传入一个Callable的具体实现类，可以对这个异步运算的任务的结果进行等待获取、判断是否完成、取消任务等操作。只有当运算完成的时候结果才能取回，如果运算尚未完成get方法将会阻塞。

一个FutureTask对象可以对调用了Callable和Runnable的对象进行包装,由于FutureTask也是Runnable接口的实现类，所以FutureTask也可以放入线程池中。

线程的状态和基本操作
线程的生命周期和五种基本状态
1.新建(new):新创建一个线程对象
2.可运行(runnable):线程对象创建后，当调用线程对象的start()方法，该线程处于就绪状态，等待被线程调度选中，获取CPU的使用权
3.运行(running):可运行状态(runnable)的线程获取了cpu时间片(timeslice)，执行程序代码。就绪状态是进入到运行状态的唯一入口，线程想进入运行状态，首先必须处于就绪状态
4.阻塞(block):处于运行状态中的线程由于某种原因，暂时放弃对CPU的使用权，停止执行，此时进入阻塞状态，直到其进入就绪状态，才有机会再次被CPU调用以进入到运行状态。

阻塞的情况有三种:
1.等待阻塞:运行状态中的线程执行wait()方法，JVM会把该线程放入等待队列(waiting queue)中，使本线程进入等待阻塞状态
2.同步阻塞:线程在获取synchronized同步锁失败(因为锁被其他线程所占用)，则JVM会把步该线程放入锁池(lock pool)中，线程会进入同步阻塞状态。
3.其他阻塞:通过调用线程的sleep()或join()或发出了I/O请求时，线程会进入阻塞状态。当sleep()状态超时、或者I/O处理完毕时，线程重新转入就绪状态

5.死亡(dead):线程run()、main()方法执行结束，或因异常退出了run()方法，则该线程结束生命周期。死亡的线程不可再次复生。

用到的线程调度算法是什么
计算机通常只有一个CPU，在任意时刻只能执行一条机器指令，每个线程只有获得CPU的使用权才能执行指令。所谓多线程的并发运行实际上就是各个线程轮流获得CPU的使用权，分别执行各自任务。在运行池中，会有多个处于就绪状态的线程在等待CPU，JVM的一项任务就是负责线程的调度，线程调度是指按照特定的机制为多个线程分配CPU的使用权

有两种调度模式:分时调度模型和抢占式调度模型。
1.分时调度模型是指让所有的线程轮流获得CPU使用权，并且平均分配每个线程占用的CPU的时间片
2.JVM采用抢占式调度模型，是指优先让可运行池中优先级高的线程占用CPU。如果可运行池中的线程优先级相同，那么就随机选择一个线程，其占用CPU。处于运行状态的线程会一直运行，直至它放弃CPU

线程的调度策略
线程调度器选择优先级最高的线程运行，但是，如果发生以下情况，就会终止线程的运行:
1.线程体中调用了yield方法让出了对CPU的占用权
2.线程体中调用了sleep方法使线程进入睡眠状态
3.线程由于IO操作受到阻塞
4.另外一个更高优先级线程出现
5.在支持时间片的系统中，该线程的时间片用完

什么是线程调度器(Thread Scheduler)和时间分片(Time Slicing)
线程调度器是一个操作系统服务，它负责为Runnable状态的线程分配CPU时间。一旦创建了一个线程并启动它，它的执行便依赖于线程调度器的实现。

时间分片是指将可用的CPU时间分配给可用的Runnable线程的过程，分配CPU时间可以基于线程优先级或者线程等待时间

线程调度并不受JVM的控制，所以由应用程序来控制它是更好的选择(也就是说不要让程序依赖于线程的优先级)

与线程同步以及线程调度相关的方法
1.wait():使一个线程处于等待(阻塞)状态，并且释放所持有的对象的锁
2.sleep():使一个正在运行的线程处于睡眠状态，是一个静态方法，调用此方法要处理InterruptedException异常。
3.notify():唤醒一个处于等待状态的线程，当然在调用此方法时，并不能确切的唤醒某一个等待状态的线程，而是由JVM确定唤醒哪个线程，而且与优先级无关
4.notifyAll():唤醒所有处于等待状态的线程，该方法并不是将对象的锁给所有线程，而状态们竞争，只有获得锁的线程才能进入就绪状态。

sleep()和wait的区别
两者都可以暂停线程的执行
区别:
1.类的不同:sleep()是Thread线程类的静态方法，wait()是Object类的方法
2.是否释放锁:sleep()不释放锁，wait()释放锁
3.用途不同:wait()通常被用于线程间交互/通信，sleep()通常用于执行暂停
4.用法不同:wait()方法被调用后，线程不会自动苏醒，需要别的线程调用同一个对象上的notify()或者notifyAll()方法。sleep()方法执行完后会自动苏醒。或者可以使用wait(long timeout)超时后线程会自动苏醒。
·如何调用wait()方法，使用if块还是循环
处于等待状态的线程可能会受到错误警报和伪唤醒，如果不在循环中检查等待条件，程序就会在没有满足结束条件的情况下退出。
wait()方法应该在循环调用，因为当线程获取到CPU时，其他条件可能还没有满足，所以在处理前，循环检测条件是否满足会更好，while是一直循环判断，而if只是判断一次，有可能判断时条件还未满足，因此不再判断且执行后面程序，而下一次判断就可能成功，所以使用while循环。
ex:

synchronized(monitor){
	while(!locked){
		monitor.wait();
	}
}

为何线程通信的方法wait()，notify()和notifyAll()被定义在Object类里
因为任何对象都可以作为锁，并且wait()，notify()等方法用于等待对象的锁或者唤醒线程，在Java的线程中并没有可供任何对象使用的锁，所以任意对象调用方法一定在Object中。
wait()，notify()和notifyAll()这些方法在同步代码块中调用。

为何wait()，notify()和notifyAll()必须在同步方法或者同步块中被调用。
1.当一个线程需要调用对象的wait()方法时，这个线程必须拥有该对象的锁，接着它就会释放这个对象锁，并进入等待状态直到其他线程调用这个对象上的notify()方法。
2.同样的，当一个线程需要调用对象的notify()方法时，它会释放这个对象的锁，以便其他在等待的线程就可以得到这个对象锁。由于所有的这些方法都需要线程持有对象的锁，这样就只能通过同步来实现，所以他们只能在同步方法或者同步块中被调用。

Thread类的yield方法有什么作用
使当前线程从执行状态(运行状态)变为可执行状态(就绪状态)。
当前线程到了就绪状态，可能当前线程会变为执行状态，也可能其他线程变为执行状态，需要看系统分配。

为什么Thread类的sleep()和yield()方法是静态的
1.Thread类的sleep()和yield()方法将在当前正在执行的线程上运行。所以在其他处于等待状态的线程上调用这些方法就是无意义的，这就是为什么这些方法是静态的。它们可以在当前正在执行的线程中工作，并避免程序员错误地认为可以在其他非运行线程调用这些方法。

线程的sleep()方法和yield()方法有什么区别
1.sleep()方法给其他线程运行机会时不考虑线程的优先级，因此会给低优先级的线程以运行的机会;yield()方法只会给相同优先级或更高优先级的线程以运行的机会
2.线程执行sleep()方法后转入阻塞(block)状态，而执行yield()方法后转入就绪(ready)状态
3.sleep()方法声明抛出InterruptedException，而yield()方法没有声明任何异常。
4.sleep()方法比yield()方法具有更好的可移植性，通常不建议使用yield()方法来控制并发线程的执行