java中的多线程_1

一、什么是进程

   进程：在操作系统中运行的某个软件/某个程序
   任何软件/程序要运行都要被加载到内存中，而内存负责运行这个软件或程序需要的内存空间，就被称为当前软甲你在内存中的一一进程。
   进程需要依赖于操作系统
   进程就是在操作系统中动态运行的静态代码

二、什么是线程？

   线程就是在操作系统系统中动态运行的静态代码【进程】中的某一项具体功能的执行过程【执行轨迹】
例如：我们在Windows操作系统上打开“暴风音影”播放电影，此时“暴风音影”就会在Windows操作系统中产生一个进程；打开“暴风音影”播放电影的时候有画面，声音，中文字幕就是这个“暴风影音”进程中的多个线程。

三、什么是多线程？

   多线程：是某一个程序在运行的时候可能产生多个不同的执行线索【执行轨迹】，这些对个不同的执行线索共同运行的情况就是多线程。
   往往我们会感觉到这些多个不同的执行线索同时被执行，实际上这是一个视觉假象，实际上在当这些多个不同的执行线索【执行轨迹】在运行时，扣个时刻只有一个执行线索【执行轨迹】在运行，只是这多个不同的执行线索快速切换而已。

四、为什么使用多线程？

   1.使用多线程的目的就是为了提高程序的执行效率
   2.解决并发问题
   并发和并行的区别？
        并行：多个处理器或多个核处理器同时处理多个任务
        并发：多个任务在同一个CPU核上，按细分的时间片轮(交替)执行，从逻辑上.来看那些      任务是同时执行。

五、多线程的创建方式以及区别 

第一种通过集成Thread类创建线程类
Thread类java提供的创建线程的线程类
创建步骤：
   1.创建一个类，集成Thread类
   2.重写Run()方法
   3.将需要由线程执行的具体动作写入run方法
 运行步骤：
    1.创建线程类的对象
    2通过线程对象调用start方法启动线程
例如：创建一个继承线程类的class

package com.wangxing.test1;

public class MyThread extends Thread{
	//创建步骤:
	//1.创建一个类，继承Thread类
	//2.重写run方法
	//3.将需要由线程执行的具体动作写入run方法
	//这里Thread类继承了Runnable接口(只有这个犯法)的run方法，并且自身有其他方法比如strat方法
	@Override
	public void run() {
		int i=0;
		while(i<=50){
			//Thread.currentThread().getName()得到进程的名称
			System.out.println(Thread.currentThread().getName()+"--i=="+i);
			i++;
		}
	}
}

创建一个执行的主方法

package com.wangxing.test1;

public class ThreadMian {
	public static void main(String[] args) {
		//运行步骤：
		//1.创建线程类的对象
		//2.通过线程对象调用start方法启动线程
		MyThread thread=new MyThread();
		MyThread thread2=new MyThread();
		thread.start();
		thread2.start();
	}
}

第二种通过实现Runnable接口创建线程类
Runnable接口--Thread类就实现过这个接口。只有一个run方法。
Tread线程类继承了Runnable接口
创建步骤:
1.创建一个类，实现Runnable接口
2.重写run方法
3.将需要由线程执行的具体动作写入run方法
运行步骤:
1.创建目标对象
2.通过Thread类的构造方法创建线程对象
3.通过线程对象调用start方法启动线程
例如：

package com.wangxing.test2;

public class MyThread implements Runnable{
	//创建步骤:
		//1.创建一个类，实现Runnable接口
		//2.重写run方法
		//3.将需要由线程执行的具体动作写入run方法
	@Override
	public void run() {
		int i=0;
		while(i<=50){
			//Thread.currentThread().getName()得到进程的名称
			System.out.println(Thread.currentThread().getName()+"--i=="+i);
			i++;
		}
	}
}

package com.wangxing.test2;

public class Main {
	public static void main(String[] args) {
		//运行步骤:
		//1.创建目标对象
		MyThread mubiao=new MyThread();
		//2.通过Thread类的构造方法创建线程对象
		Thread th1=new Thread(mubiao);
		//3.通过线程对象调用start方法启动线程
		th1.start();
	}
}

第三种通过Callable和Future接口创建线程
java.util.concurrent.Callable接口--这个接口中只有一个方法call()
java.util.concurrent.Future接口--有一个重要方法get()
   1. public boolean cancel(boolean mayInterruptIfRunning)
               是否取消正在执行的线程任务[false为取消任务]
    2. public boolean isCancelled()判断是否是线程任务没有运行结束之前取消线程
    3. public boolean isDone()判断线程任务是否正常执行完毕
    4. V get()得到线程任务的执行结果
java.util.concurrent.FutureTask类--继承了Runnable接口
    1. public boolean cancel(boolean mayInterruptIfRunning)是否取消正在执行的线程任务
    2. public boolean isCancelled()判断是否是线程任务没有运行结束之前取消线程
    3. public boolean isDone()判断线程任务是否正常执行完毕
    4. V get()得到线程任务的执行结果
创建步骤:
1.创建一个类，实现Callable接口
2.重写call();
3.将需要由线程执行的具体动作写入call()方法
注意:实现Callable接口的时候需要指定线程执行结果的返回值类型
运行步骤:
1.创建目标对象
2.通过FutureTask类的构造方法public FutureTask(Callable<V> callable)封装目标对象成Runnable子类对象
3.通过Thread类的构造方法public Thread(Runnable runnable)创建线程对象
例如：

package com.wangxing.test3;

import java.util.concurrent.FutureTask;

public class Main {
	public static void main(String[] args) {
		//运行步骤:
		//1.创建目标对象
		MyThread mubiao=new MyThread();
		//2.通过FutureTask类的构造方法public FutureTask(Callable<V> callable)封装目标对象成Runnable子类对象
		FutureTask  futruetask1=new FutureTask(mubiao);
		FutureTask  futruetask2=new FutureTask(mubiao);
		//3.通过Thread类的构造方法public Thread(Runnable runnable)创建线程对象
		Thread th1=new Thread(futruetask1);
		Thread th2=new Thread(futruetask2);
		th1.start();
		th2.start();
	}
}

package com.wangxing.test3;

import java.util.concurrent.FutureTask;

public class Main {
	public static void main(String[] args) {
		// 运行步骤:
		// 1.创建目标对象
		MyThread mubiao = new MyThread();
		// 2.通过FutureTask类的构造方法public FutureTask(Callable<V>
		// callable)封装目标对象成Runnable子类对象
		FutureTask futruetask1 = new FutureTask(mubiao);
		FutureTask futruetask2 = new FutureTask(mubiao);
		// 3.通过Thread类的构造方法public Thread(Runnable runnable)创建线程对象
		Thread th1 = new Thread(futruetask1);
		Thread th2 = new Thread(futruetask2);
		th1.start();
		th2.start();
		//是否取消正在执行的线程任务
		//futruetask1.cancel(false);
		//判断是否是线程任务没有运行结束之前取消线程
		//System.out.println(futruetask1.isCancelled());
		//判断线程任务是否正常执行完毕
		//System.out.println(futruetask1.isDone());
		try {
			// 得到线程运行结果
			int res = (Integer) futruetask1.get();
			System.out.println("线程1的运行结果==" + res);
		} catch (Exception e) {
			e.printStackTrace();
		}
	}
}

第四种通过线程池创建多线程【使用的比较少，所以不强调】

多线程的创建方式的区别***
例如我们用卖票的过程演示

继承Thread类创建线程类
    1.创建新类继承Thread类重写run方法
    2.run方法没有返回值，不能声明抛出异常
    3.创建Thread类的子类对象【线程对象】，通过子类对象调用start方法启动线程
    4.无法资源共享
    5.不考虑资源共享时

package com.wangxing.test1;
public class MyThread2 extends Thread{
	//创建步骤:
	//1.创建一个类，继承Thread类
	//2.重写run方法
	//3.将需要由线程执行的具体动作写入run方法
	//这里Thread类继承了Runnable接口(只有这个犯法)的run方法，并且自身有其他方法比如strat方法
	private int piao=5;
	@Override
	public void run() {
		boolean flag=true;
		while(flag){
			if(piao<=0){
				flag=false;
			}else{
				System.out.println(Thread.currentThread().getName()+",卖出了一张票，剩余了"+--piao+"张");
			}
		}	
	}
	
}

package com.wangxing.test1;

public class ThreadMian {
	public static void main(String[] args) {
		//运行步骤：
		//1.创建线程类的对象
		//2.通过线程对象调用start方法启动线程
		/*MyThread thread=new MyThread();
		MyThread thread2=new MyThread();
		thread.start();
		thread2.start();*/
		MyThread2 th1=new MyThread2();
		MyThread2 th2=new MyThread2();
		th1.start();
		th2.start();
	}
}

实现Runnable接口
    1.创建新类实现Runnable接口重写run方法
    2.run方法没有返回值，不能声明抛出异常
    3.创建实现Runnable接口的子类对象【目标对象】，通过Thread的构造方法将目标对象转换成线程对象，通过线程对象调用start方法启动线程
    4.可以资源共享
    5.考虑资源共享时

package com.wangxing.test2;

public class MyThread2 implements Runnable{
	//创建步骤:
		//1.创建一个类，实现Runnable接口
		//2.重写run方法
		//3.将需要由线程执行的具体动作写入run方法
	private int piao=5;
	@Override
	public void run() {
		boolean flag=true;
		while(flag){
			if(piao<=0){
				flag=false;
			}else{
				System.out.println(Thread.currentThread().getName()+",卖出了一张票，剩余了"+--piao+"张");
			}
		}	
	}
}

package com.wangxing.test2;

public class Main {

	public static void main(String[] args) {
		//运行步骤:
		/*//1.创建目标对象
		MyThread mubiao=new MyThread();
		//2.通过Thread类的构造方法创建线程对象
		Thread th1=new Thread(mubiao);
		//3.通过线程对象调用start方法启动线程
		th1.start();*/
		MyThread2 mubiao=new MyThread2();
		Thread th1=new Thread(mubiao);
		Thread th2=new Thread(mubiao);
		th1.start();
		th2.start();
	}
}

Callable和Future接口
    1.创建新类实现Callable接口重写call方法，注意Callable接口的泛型类型
    2.call方法有返回值，通过Future接口提供的get方法得到返回值,可以声明抛出异常
    3.创建实现Callable接口的子类对象【目标对象】，通过Future接口的子类FutureTask将Callable接口的子类转换成Runnable接口类型，通过Thread的构造方法将Runnable接口类型对象转换成线程对象，通过线程对象调用start方法启动线程。
    4.可以资源共享
    5.考虑资源共享时，异步编程