java---多线程

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(Callablecallable)封装目标对象为Runnable子类对象

3.通过Thread类的构造方法public Thread(Runnable runnable)创建线程对象

例如：

package com.object.test3;

import java.util.concurrent.Callable;

public class MyThread implements Callable{
	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 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.考虑资源共享时，异步编程