Java中的多线程

最新推荐文章于 2023-02-20 18:44:16 发布

山ii

最新推荐文章于 2023-02-20 18:44:16 发布

阅读量121

点赞数

分类专栏： Java基础文章标签： java 正则表达式开发语言后端

本文链接：https://blog.csdn.net/weixin_52821030/article/details/121422392

版权

Java基础专栏收录该内容

50 篇文章 1 订阅

订阅专栏

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)

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

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<V> 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接口的子类对象【目标对象】，通过Future接口子类FutureTask将Callable接口的子类转换成Runnable接口类型，通过Thread的构造方法将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();
		

		
		
		}
	}