多线程1

10.1.什么是多线程？
1.什么是进程？

进程：在操作系统中运行的某个软件/某个程序（主要是指在内存中）。
任何软件/程序要运行都要被加载到内存中，而内存负责运行这个软件/程序所需要的那些内存空间，就被称为当前软件在内存中的一个进程。
1.进程需要依赖与操作系统
进程就是在操作系统中动态运行的静态代码。
2.什么是线程？
线程就是在操作系统中动态运行的静态代码中的某一项具体功能的执行过程【执行轨迹/执行线索】。
例如：
我们在window操作系统上打开“暴风影音”播放电影，此时“暴风影音”就会在window操作系统中产生一个进程；打开“暴风影音”播放电影的时候有画面，声音，中文字幕等等,这些画面，声音，中文字幕就是这个“暴风影音”进程中的多个线程。

3.什么是多线程？
多线程：某一个程序在运行的时候可能会产生多个不同的执行线索【执行轨迹】，这些多个不同的执行线索【执行轨迹】共同运行的情况就是多线程。
往往我们会感觉到这些多个不同的执行线索【执行轨迹】同时执行，实际上这时一种错觉假象，实际上当这些多个不同的执行线索【执行轨迹】在运行的时候，某一个时刻只用一个执行线索【执行轨迹】在运行，只是这多个不同的执行线索【执行轨迹】快速的切换而已。
4.为什么使用多线程？
①使用多线程的目的就是为了提高程序的执行效率。
②解决并发问题。
并行和并发有什么区别？
并行：多个处理器或多核处理器同时处理多个任务。
并发：多个任务在同一个 CPU 核上，按细分的时间片轮流(交替)执行，从逻辑上来看那些任务是同时执行。
如下图：【并发 = 两个队列和一台咖啡机】 【并行 = 两个队列和两台咖啡机】

10.2.多线程的创建方式以及区别
Java中的线程
当一个java程序启动运行以后，至少有2个线程在运行。
1.主线程,就是java程序的主方法执行线索
2.垃圾回收线程。
Java中多线程的创建方式

通过Callable和Future接口创建线程
通过这两个接口创建线程，你要知道这两个接口的作用，下面我们就来了解这两个接口：
通过实现Runnable接口创建多线程时，Thread类的作用就是把run()方法包装成线程的执行体,那么，是否可以直接把任意方法都包装成线程的执行体呢?
从JAVA5开始，JAVA提供提供了Callable接口，该接口是Runnable接口的增强版，Callable接口提供了一个call()方法可以作为线程执行体，但call()方法比run()方法功能更强大，call()方法的功能的强大体现在：
1、call()方法可以有返回值；
2、call()方法可以声明抛出异常；
从这里可以看出，完全可以提供一个Callable对象作为Thread的target，而该线程的线程执行体就是call()方法。
问题是：Callable接口是JAVA新增的接口，而且它不是Runnable接口的子接口，所以Callable对象不能直接作为Thread的target。还有一个原因就是：call()方法有返回值，call()方法不是直接调用，而是作为线程执行体被调用的，所以这里涉及获取call()方法返回值的问题。
于是，JAVA5提供了Future接口来代表Callable接口里call()方法的返回值，并为Future接口提供了一个FutureTask实现类，该类实现了Future接口，并实现了Runnable接口，所以FutureTask可以作为Thread类的target，同时也解决了Callable对象不能作为Thread类的target这一问题。
在Future接口里定义了如下几个公共方法来控制与它关联的Callable任务：
1、boolean cancel(boolean mayInterruptIfRunning)：试图取消Future里关联的Callable任务；
2、V get()：返回Callable任务里call()方法的返回值，调用该方法将导致程序阻塞，必须等到子线程结束以后才会得到返回值；
3、V get(long timeout, TimeUnit unit)：返回Callable任务里call()方法的返回值。该方法让程序最多阻塞timeout和unit指定的时间，如果经过指定时间后，Callable任务依然没有返回值，将会抛出TimeoutException异常；
4、boolean isCancelled()：如果Callable任务正常完成前被取消，则返回true；
5、boolean isDone()：如果Callable任务已经完成， 则返回true；
这种方式创建并启动多线程的步骤如下：
1、创建Callable接口实现类，并实现call()方法，该方法将作为线程执行体，且该方法有返回值，再创建Callable实现类的实例；
2、使用FutureTask类来包装Callable对象，该FutureTask对象封装了该Callable对象的call()方法的返回值；
3、使用FutureTask对象作为Thread对象的target创建并启动新线程；
4、调用FutureTask对象的get()方法来获得子线程执行结束后的返回值。

第一种，通过继承Thread类创建线程类

package com.lx.test1;
/**
 *  1.创建一个类，继承Thread类
	2.重写run方法
	3.将需要由线程执行的具体动作写入run方法
 * @author Administrator
 *
 */
public class TestThread extends Thread{
	@Override
	public void run() {
		//得到当前线程的名称
		String name=Thread.currentThread().getName();
		for(int i=1;i<=50;i++) {
			System.out.println(name+"--i=="+i);
		}
	}
}

运行

package com.lx.test1;
public class TestMain {
	public static void main(String[] args) {
		/**
		   * 启动线程的步骤
		 * 1.创建线程对象【继承Thread类的对象】
		 * 2.通过线程对象调用start方法启动线程
		 */
		TestThread  tth1=new TestThread();
		tth1.start();
		TestThread  tth2=new TestThread();
		tth2.start();
	}
}

第二种，通过实现Runnable接口创建线程类

package com.lx.test1;
/**
 * 	1.创建一个类，实现Runnable接口
	2.重写run方法
	3.将需要由线程执行的具体动作写入run方法
 * @author Administrator
 *
 */
public class MyThread implements Runnable{
	@Override
	public void run() {
		//得到当前线程的名称
		String name=Thread.currentThread().getName();
		for(int i=1;i<=100;i++) {
			System.out.println(name+"--i=="+i);
			}
	}
}

package com.lx.test1;
public class TestMain {
	public static void main(String[] args) {
		/*
		 * 1.创建有线程类执行的目标对象【实现Runnable接口的java类对象】
		 * 2.创建线程对象【java.lang.Thread类的对象】
		 *  public Thread(Runnable target) 
		 *  public Thread(Runnable target, String name)
		 * 3.调用start方法启动线程运行
		 */
		MyThread mth=new MyThread();
		Thread th1=new Thread(mth);
		th1.start();
		Thread th2=new Thread(mth);
		th2.start();
	}
}

通过Callable和Future接口创建线程

package com.lx.test1;
import java.util.concurrent.Callable;
public class MyCallable implements Callable<Integer>{
	@Override
	public Integer call() throws Exception {
		int i=1;
		//得到当前线程的名称
		String name=Thread.currentThread().getName();
		for(;i<=100;i++) {
			System.out.println(name+"--i=="+i);
		}
		return i;
	}
}

package com.lx.test1;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.FutureTask;
public class TestMain {

	public static void main(String[] args) {
        //目标对象
		MyCallable  mycall=new MyCallable();
//目标对象的封装
		FutureTask<Integer> task1=new FutureTask(mycall);
//线程对象
		Thread th1=new Thread(task1);
//启动线程
		th1.start();
		try {
            //是否取消正在执行的线程任务
			task1.cancel(true);
//判断是否是线程任务没有运行结束之前取消线程认为
			if(task1.isCancelled()) {
				System.out.println("关闭窗口！");
			}
//判断线程任务是否正常执行完毕
			if(task1.isDone()) {
//得到线程任务的执行结果
				int task_Thread_1=task1.get();
				System.out.println("线程1的运行结果--"+task_Thread_1);
			}else {
				
			}
		} catch (Exception e) {
			e.printStackTrace();
		}
		FutureTask<Integer> task2=new FutureTask(mycall);
		Thread th2=new Thread(task2);
		th2.start();
		try {
			int task_Thread_2=task2.get();
			System.out.println("线程2的运行结果--"+task_Thread_2);
		} catch (Exception e) {
			e.printStackTrace();
		}
	}
}