Java---多线程的创建

1.什么是进程？

   进程：在操作系统中运行的某个软件/程序

   任何软件/程序在运行中都要被加载到内存中，而内存负责运行这个软件/程序所需要的内存空         间，就被称作在内存中的一个进程

   进程需要依赖与系统

   进程就是在操作系统中动态运行的静态代码

2.什么是线程

   线程就是在操作系统中动态运行的静态代码【进程】中的某一项具体功能的执行过程【执行轨迹/执行线索】

例如：

   我们在window操作系统上打开“暴风影音”播放电影，此时“暴风影音”就会在window操作系    统中产     生一个进程；打开“暴风影音”播放电影的时候有画面，声音，中文字幕等等,这些    画面，声音，中     文字幕就是这个“暴风影音”进程中的多个线程。

3.什么是多线程

    多线程：某一个程序在运行时可能会产生多个不同的执行线索【执行轨迹】，着多个不同                    的执行线索【执行轨迹】共同运行的情况下就是多线程。

     往往我们会感觉到这些不同的执行线索【执行轨迹】同事之星，实际上这是一种错觉假         象。其 实当这些多个不同的执行线索【执行轨迹】在运行时，某一个时刻只有一个执行         线索在运行，只是这对个不同的执行线索【执行轨迹】快速切换而已

4.为什么使用多线程

   1.使用多线程的目的就是为了提高程序执行效率。

   2.解决并发问题

   3.并行和并发有什么区别

         并行：多个处理器或多核处理器同事处理多个任务

         并发：多个任务在同一个CPU核上，安细分的时间片轮流(交替)执行，从逻辑上看是那                         些任务同时执行

5.多线程的创建方式以及区别

    1.通过继承Thread类创建线程，Thread类是java提供的创建线程的类

      创建步骤：

1.创建一个类，继承Thread类

2.重写run方法

3.需要由线程执行的具体动作写入run方法

运行步骤：

  1.创建线程类对象

   2.通过线程对象调用start方法启动线程

例如：

package com.object.test1;

public class MyThread extends Thread{
	public void run() {
			for(int i=1;i<=50;i++){
				String name=Thread.currentThread().getName();
				System.out.println(name+"--i=="+i);
			}
		}
}

package com.object.test1;

public class MyMain {

	public static void main(String[] args) {
		//创建线程对象
		MyThread my=new MyThread();
		MyThread my2=new MyThread();
		//通过线程对象调用start方法启动线程
        my.start();
        my2.start();
	}

}

2.通过实现Runnable接口创建线程类

   Runnable接口---Thread类就实现过这个接口，只有一个run方法

   创建步骤：

1.创建一个类，实现Runnable接口

2.重写run方法

3.将需要由线程执行到具体动作写入run方法

运行步骤：

1.创建目标对象

2.通过Thread类的构造方法创建线程对象

3.通过线程对象调用start方法启动线程。···

例如：

package com.object.test2;

public class MyThreadClass implements Runnable{
	public void run() {
		for(int i=1;i<=50;i++){
			//得到当前正在运行的线程对象的名称
			String name=Thread.currentThread().getName();
			System.out.println(name+"--i=="+i);
		}
		
	}
}

package com.object.test2;

public class MyMain {

	public static void main(String[] args) {
		//创建目标对象
		MyThreadClass my1=new MyThreadClass();
		//创建线程对象
		Thread th1=new Thread(my1);
		Thread th2=new Thread(my1);
		//调用start方法启动线程
		th1.start();
		th2.start();
	}

}

3.通过Callable和Future接口创建线程

1.  java.util.concurrent.Callable接口--这个接口中只有一个方法call()

2.  java.util.concurrent.Future接口--有一个重要方法get()

1.public boolean cancle(boolean mayInterruptIfRunning)---是否取消正在执行的线程任务[false为取消任务]

2.public boolean isCancelled()---判断是否是线程任务没有运行结束之前取消线程

3.public  boolean isDone---判断线程任务·是否正常执行完毕

4.V    get()---得到线程任务的执行结果

3. 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.object.test3;

import java.util.concurrent.Callable;

public class MyThread implements Callable<Integer>{
	public Integer call() throws Exception {
		int i=1;
		while(i<=50){
			//得到当前线程的名称
			String name=Thread.currentThread().getName();
			System.out.println(name+"--i=="+i);	
			i++;
		}
		return i;
	}

}

package com.object.test3;

import java.util.concurrent.FutureTask;

public class MyMain {

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

}

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

6.多线程的创建方式的区别

   1.继承Thread类

1.创建新类继承Thread类重写run方法

2.run方法没有返回值，不能声明抛出异常

3.创建Thread类的子类对象【线程对象】，通过子类对象调用start方法启动线程

4.无法共享资源

5.不考虑资源共享时 

package com.object.test1;

public class MyThread2 extends Thread{
	int ticket=5;
	public void run() {
			boolean flag=true;
			while(flag){
				if(ticket<=0){
					flag=false;
				}else{
					String name=Thread.currentThread().getName();
					System.out.println(name+"，卖出1张票，还剩"+(--ticket)+"张");
				}
			}
		}
}

package com.object.test1;

public class MyMain {

	public static void main(String[] args) {
		MyThread2 my1=new MyThread2();
		MyThread2 my2=new MyThread2();
		my1.start();
		my2.start();
	}

}

2.实现Runnable接口

1.创建新类实现Runnable接口，重写run方法

2.run方法没有返回值，不能声明抛出异常

3.创建实现Runnable接口的子类对象【目标对象】，通过Thread的的构造方法将目标对象转换成线程对象，通过线程对象调用start方法启动线程

4.可以共享资源

5.考虑资源共享时

package com.object.test2;

public class MyThreadClass2 implements Runnable{
	int ticket=5;
	public void run() {
		boolean flag=true;
		while(flag){
			if(ticket<=0){
				flag=false;
			}else{
				String name=Thread.currentThread().getName();
				System.out.println(name+",卖出一张票，还剩"+(--ticket)+"张");
			}
		}
	}
}

package com.object.test2;

public class MyMain {

	public static void main(String[] args) {
		 MyThreadClass2 my1=new  MyThreadClass2();
		 Thread th1=new Thread(my1);
		 Thread th2=new Thread(my1);
		 th1.start();
		 th2.start();
	}

}

3.Callable和Future接口

1.创建新类实现Callable接口重写call()方法，注意Callable接口的泛型类型

2.call方法有返回值，通过Future接口提供的get方法得到返回值，可以声明抛出异常

3.创建实现Callable接口的子类转换成Runnable接口类型，通过Thread的构造方法将Runnable接口类型对象转换成线程对象，通过线程对象调用start方法启动线程

4.可以资源共享

5.考虑资源共享时，异步编程