Java多线程

最新推荐文章于 2024-07-29 18:48:35 发布

m0_60165694

最新推荐文章于 2024-07-29 18:48:35 发布

阅读量110

点赞数

文章标签： java 开发语言后端

本文链接：https://blog.csdn.net/m0_60165694/article/details/121430369

版权

1.什么是进程？

进程：在操作系统中运行的某个软件/某个程序
任何软件/程序要运行都要被加载到内存中，而内存负责运行这个软件/程序所需要的那些内存空间，就会被称为当前软件在内存中的一个进程
进程需要依赖于操作系统
进程就是在操作系中动态运行的静态代码
2.什么是线程？

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

例如：

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

3.什么是多线程？

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

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

4.为什么使用多线程？

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

2.解决并发问题

并行和并发有什么区别？

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

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

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

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

Thread类java提供的创建线程的线程类

创建步骤：

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

2.重写run方法

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

运行步骤：

1.创建线程类的对象
2.通过线程对象调用start方法启用线程

例如：

package com.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.test1;
 
public class MyThreadMain {
 
public static void main(String[] args) {
		//创建线程类的对象
		MyThread my=new MyThread();
		MyThread my1=new MyThread();
		//通过线程对象调用start方法启动线程
		my.start();
		my1.start();
		
	}
 
}

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

Runnable接口—Thread类就实现过这个接口

只有一个run方法。

创建步骤：

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

2.重写run方法

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

运行步骤：

1.创建目标对象

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

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

例如：

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

package com.test2;
 
public class MyRunnableMain {
 
	public static void main(String[] args) {
		//创建目标的对象
		MyRunnable my1=new MyRunnable();
		//通过Thread类的构造方法创建线程对象
		Thread th1=new Thread(my1);
		Thread th2=new Thread(my1);
		th1.start();
		th2.start();
 
	}
 
}

第三种，通过Callable和Future接口创建线程

java.tuile.concurrent.Callable接口—这个接口中只有一个方法call()

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

1.public boolean cancel(boolean mayInterruptIfRunning)

2.public boolean isCanCelled()判断是否是线程任务没有运行接触之前取消线程

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

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

1.public boolean cancel(boolean mayInterruptIfRunning)

是否取消正在执行的线程任务【false为取消任务】

2.public boolean isCanCelled()判断是否是线程任务没有运行接触之前取消线程

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

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

创建步骤：

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

2.重写call();

3.将需要由线程执行的具体动作写入call()方法

注意：实现Callable接口的时候需要指定线程执行结果的返回值类型

运行步骤：

1.创建目标对象

2.通过FutureTask类的构造方法public FutureTask(Callable callable)封装目标对象成Runnable子类对象

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

例如：

package com.test3;
 
import java.util.concurrent.Callable;
 
public class MyThread implements Callable<Integer>{
 
	@Override
	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.test3;
 
import java.util.concurrent.FutureTask;
 
public class MyThreadMain {
	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);
		//3.通过Thread类的构造方法public Thread(Runnable runnable)创建线程对象
		Thread th1=new Thread(ft1);
		Thread th2=new Thread(ft2);
		//启动线程
		th1.start();		
		th2.start();
		
		//是否取消正在执行的线程任务
		//ft1.cancel(false);
		//判断是否是线程任务没有运行结束之前取消线程
		//System.out.println(ft1.isCancelled());
		//判断线程任务是否正常执行完毕
		//System.out.println(ft1.isDone());
		//V  get()得到线程任务的执行结果
		try{
		int res=(Integer)ft1.get();
		System.out.println("线程1的运行结果="+res);
		}catch(Exception e){
			e.printStackTrace();
		}
		
		}
	}

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

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

继承Thread类

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

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

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

4.无法资源共享

package com.test1;
/**
 * 1.创建一个类，继承Thread类
 * 2.重写run方法
 * 3.将需要由线程执行的具体动作写入run方法
 * @author zxc
 *
 */
public class MyThread2 extends Thread{
	private int piao=5;
	public void run(){
		boolean flag=true;
		while(flag){
			if(piao<=0){
				flag=false;
			}else{
				String name=Thread.currentThread().getName();
				System.out.println(name+"卖出1张票，还剩"+(--piao)+"张");
			}
		}
	}
	}

 
package com.test1;
 
public class MyThreadMain {
 
public static void main(String[] args) {
		//创建线程类的对象
		MyThread2 my=new MyThread2();
		MyThread2 my1=new MyThread2();
		//通过线程对象调用start方法启动线程
		my.start();
		my1.start();
		
	}
 
}

实现Runnable接口

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

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

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

4.可以资源共享

5.考虑资源共享时

package com.test2;
/**
 * 1.创建一个类，实现Runnable接口
 * 2.重写run方法
 * 3.将需要由线程执行的具体动作写入run方法
 * @author zxc
 *
 */
public class MyRunnable2 implements Runnable{
	private int piao=5;
	@Override
	public void run() {
		boolean flag=true;
		while(flag){
			if(piao<=0){
				flag=false;
			}else{
				String name=Thread.currentThread().getName();
				System.out.println(name+"卖出1张票，还剩"+(--piao)+"张");
			}
		}
		
	}
 
}
package com.test2;
 
public class MyRunnableMain {
 
	public static void main(String[] args) {
		//创建目标的对象
		MyRunnable2 my1=new MyRunnable2();
		//通过Thread类的构造方法创建线程对象
		Thread th1=new Thread(my1);
		Thread th2=new Thread(my1);
		th1.start();
		th2.start();
 
	}
 
}

    Callable和Futuer接口

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

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

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

    4.可以资源共享

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

package com.test3;
/**
 * 1.创建新类实现Callble接口
 * 2.重写call()方法
 * 3.将需要由线程执行的具体动作写入call()方法
 */
import java.util.concurrent.Callable;
 
public class MyThread2 implements Callable<Integer>{
	private int piao=5;
	@Override
	public Integer call() throws Exception {
		boolean flag=true;
		 while(flag){
			 if(piao<=0){
				 flag=false;
			 }else{
				 String name=Thread.currentThread().getName();
				 System.out.println(name+"卖出一张票，还剩"+(--piao)+"张");
			 }
		 }
		return null;
	}
 
 
 
	}

package com.test3;
 
import java.util.concurrent.FutureTask;
 
public class MyThreadMain {
	public static void main(String []args){
			//创建目标对象
		MyThread2 my1=new MyThread2();
		//通过FutureTask类的构造方法public FutureTask(Callable<V> callable)封装目标对象成Runnable子类对象
		FutureTask ft1=new FutureTask(my1);
		FutureTask ft2=new FutureTask(my1);
		//3.通过Thread类的构造方法public Thread(Runnable runnable)创建线程对象
		Thread th1=new Thread(ft1);
		Thread th2=new Thread(ft2);
		//启动线程
		th1.start();		
		th2.start();		
		}
	}