JAVA多线程基础

最新推荐文章于 2024-09-27 00:45:01 发布
最新推荐文章于 2024-09-27 00:45:01 发布
阅读量4.1k 收藏 18
点赞数 5
文章标签： javase 多线程 java thread 并发编程
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_47600732/article/details/115012547
版权

JAVA多线程基础

1.什么是并发原理？

多线程：多线程允许我们“同时”执行多段代码。

线程是并发运行的，线程调度会统一规划CPU时间，将CPU的时间划分为若干片段，然后尽可能的均匀分配给所要并发运行的线程，每个线程在获取CPU时间片段后CPU就会运行它的任务，当时间片段用完后，Cpu会离开并执行获取到CPu时间片的线程，所以，所有线程并非真正的“同时”运行着代码，而是走走停停，这种微观上走走停停，在宏观上感觉是同步进行的现象称为“并发运行”。

2.创建线程Thread

1. 方式一：继承Thread并重写run方法来定义线程任务；
public class ThreadDemo {
	public static void main(String[] args) {
		Thread t1=new MyThread1();
		Thread t2=new MyThread2();
	/*
	* 启动线程不是调用Run方法，而是要调用start（）方法,
	* 线程开始并发运行时会自动调用run（）方法。
	*/
		t1.start();
		t2.start();
	}
}

class MyThread1 extends Thread{
	public void run(){
		for(int i=0;i<100;i++){
			System.out.println("你好，兄弟");
		}
	}
}

class MyThread2 extends Thread{
	public void run(){
		for(int i=0;i<100;i++){
			System.out.println("我不好！！！！！");
		}
	}
}

​ 第一种创建线程的方式有两个不足的地方
​ 1.由于java是单继承，这就倒置若继承了Thread就不能在继承其他的类，在实际开发中并不方便，因为无法重用其他类的某些方法。
​ 2.由于继承Thread后重写run（）方法定义线程要执行的任务，这就导致了 线程与线程执行任务有一个必然的耦合关系，不利于线程的重用。

2.第二种创建线程的方法:实现Runnable接口单独定义线程任务
public class ThreadDemo2 {
	public static void main(String[] args) {
		//创建线程任务
		MyThread3 m1=new MyThread3();
		MyThread4 m2=new MyThread4();
		//创建线程并执行任务
		Thread t1=new Thread(m1);
		Thread t2=new Thread(m2);
		
		//执行任务
		t1.start();
		t2.start();
	 }
}
//线程任务
class MyThread3 implements Runnable {
	public void run() {
		for(int i=0;i<100;i++){
			System.out.println("淦淦淦！");
		}
	}
}

class MyThread4 implements Runnable{
	public void run() {
		for(int i=0;i<100;i++){
			System.out.println("草草草！");
		}
	}
}

​ 使用Runnable创建并使用线程实现Runnable接口并重写run方法来定义线程体，然后再创建线程的时候将Runnable的实例传入并启动线程，这样做的好处在于可以线程和线程要执行任务分离，降低耦合度。

3.使用匿名内部类实现创建线程的两种方式
public class ThreadDemo3 {
	public static void main(String[] args) {
		//创建线程
		Thread t1=new Thread(){
			
			public void run() {
				for(int i=0;i<100;i++){
					System.out.println("淦淦淦！");
				}
			}
		};
		
		//创建线程任务
		Runnable r=new Runnable() {
		
			public void run() {
				for(int i=0;i<100;i++){
					System.out.println("草草草！");
				}
			}
		};
		Thread t2=new Thread(r);
		
		//启动线程
		t1.start();
		t2.start();
	}
}

3.currentThread();

线程提供了static Thread currentThread（）,该方法可以获取运行这个方法的线程，java中所有的代码都是线程运行的，main方法也不例外，jvm启动后会启动一个线程来执行main方法，通常我们成执行main方法的线程为“主线程”.

public class CurrentThreadDemo {
    
	public static void dosome(){
		Thread t=Thread.currentThread();
		//Thread[main,5,main]
		//Thread[线程名称，优先级，线程组]
		System.out.println("运行dosome的线程："+t);
	}
    
	public static void main(String[] args) {
		dosome();
		Thread t2=Thread.currentThread();
		System.out.println(t2);
		Thread t3=new Thread(){
			public void run(){
				Thread r=Thread.currentThread();
				System.out.println("t3线程"+r);
			}
		};
		
		//启动
		t3.start();
	}
}

代码运行结果：

运行dosome的线程：Thread[main,5,main]
Thread[main,5,main]
t3线程Thread[Thread-0,5,main]

4.线程的优先级

​ 一.线程的优先级：线程调用start（）方法后纳入线程调度统一管理，线程不能主动获取cpu时间片段，只能被动分配，调正先线程优先级可大程度的改善某个线程获取cpu时间片段的概率，理论上线程优先级越高的线程获取cpu时间片段的次数越多。

​ 二.线程优先级10个等级（1-10）

​ 1.表示优先级最低

​ 5.表示默认

​ 10.表示优先级最高

​ 三.设置优先级方法setPriority(int p);

​ 线程三个常量分别表示最低，最高，默认

public class priorityDemo {
	public static void main(String[] args) {
		Thread t1=new Thread(){
			public void run(){
				for(int i=0;i<1000;i++){
					System.out.println("max");
				}
			}
		};
		Thread t2=new Thread(){
			public void run(){
				for(int i=0;i<1000;i++){
					System.out.println("默认");
				}
			}
		};
		Thread t3=new Thread(){
			public void run(){
				for(int i=0;i<1000;i++){
					System.out.println("min");
				}
			}
		};
		
		//设置线程的优先级
		t1.setPriority(Thread.MAX_PRIORITY);//10
		t2.setPriority(Thread.NORM_PRIORITY);//5
		t3.setPriority(Thread.MIN_PRIORITY);//1
		
		//启动
		t1.start();
		t2.start();
		t3.start();
	}
}

结果分析：

max先输出完，下来是默认，再是min。

5.睡眠阻塞状态

1.static void sleep(long ms)当一个线程执行完sleep方法后就会进入阻塞状态指定的毫秒数，超时后线程会自动回到runnable就绪状态等待两次并发运行，该方法要求必须处理interruptedException。

2.睡眠阻塞状态时被其他线程调用interruput方法时，会抛出该中断异常并打断睡眠阻塞状态。

3.interrupt()方法用于中断线程，但是若线程处于阻塞状态时中断阻塞，若线程没有处于阻塞状态则线程直接被中断。

1.案例一：用睡眠阻塞模拟小品事件
public class SleepDemo {
	public static void main(String[] args) {
		
		Thread qiang=new Thread(){
			public void run(){
				System.out.println("强哥：刚贴上面膜，睡会。。。。。");
				try {
					Thread.sleep(10000);
					System.out.println("我醒来了！");
				} catch (InterruptedException e) {
					System.out.println("强哥：卧槽，咋回事！小老弟");
				}
			}
		};
		
		
		Thread chao=new Thread(){
			public void run(){
				System.out.println("刘永超：我开始砸墙了");
				for(int i=0;i<5;i++){
					System.out.println("刘永超：80");
					try {
						Thread.sleep(1000);
					} catch (InterruptedException e) {
						e.printStackTrace();
					}
				}
				System.out.println("刘永超：咣当，搞定！！");
				qiang.interrupt();
			}
		};
		
		//启动
		chao.start();
		qiang.start();
	}
}
运行结果：

强哥：刚贴上面膜，睡会。。。。。
刘永超：我开始砸墙了
刘永超：80
刘永超：80
刘永超：80
刘永超：80
刘永超：80
刘永超：咣当，搞定！！
强哥：卧槽，咋回事！小老弟

2.案例二：用睡眠阻塞状态实现图片切换
public class SleepDemo2 {
	public static void main(String[] args) {
		JFrame rame=new JFrame();//相框
		rame.setSize(350,350);//大小
		JPanel panel=new JPanel();//面板
		panel.setSize(350,350);
		rame.setContentPane(panel);//把面板放到相框中
		rame.setVisible(true);//设置相框可见
		//点击关闭按钮同时关闭程序
		rame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
		Thread t=new Thread(){
			public void run(){
				int i=0;
				while(true){
					i=i==0?1:0;
					try {
						Thread.sleep(500);
						if(i==0){
							panel.setBackground(Color.BLACK);
						}else{
							panel.setBackground(Color.green);
						}
					} catch (Exception e) {
						e.printStackTrace();
					}
				}
			}
		};
		//启动
		t.start();
	}
}
运行结果：

一个面板中会有两张分别为红色和绿色底色来回切换，切换间隔为500ms。

6.join（）方法

线程提供了一个方法void join（）该方法允许线程在另一个线程上等待，直到执行完毕后再继续运行，这样做可以协调线程间的“同步运行”。

同步运行：代码执行有先后顺序（单线程下运行时是同步的，多线程下也可以进行同步运行操作）

异步运行：代码各执行各的。（多线程下运行代码时是异步的）

案例：模拟图片下载
public class JoinDemo {
	public static void main(String[] args) {
		//线程（下载）
		Thread download=new Thread(){
			public void run(){
				System.out.println("开始下载图片。。");
				for(int i=10;i<=100;i=i+10){
					try {
						System.out.println("下载进度："+i+"%");
						sleep(100);
					} catch (InterruptedException e) {
						// TODO Auto-generated catch block
						e.printStackTrace();
					}
				}
				System.out.println("图片下载完毕！！");
			}
		};
		
		
		//线程（显示图片）
		Thread show=new Thread(){
			public void run(){
				try {
					download.join();
					System.out.println("图片显示完毕");
				} catch (InterruptedException e) {
					// TODO Auto-generated catch block
					e.printStackTrace();
				}
			}
		};
		
		
		//运行
		download.start();
		show.start();
	}
}
运行结果：

开始下载图片。。
下载进度：10%
下载进度：20%
下载进度：30%
下载进度：40%
下载进度：50%
下载进度：60%
下载进度：70%
下载进度：80%
下载进度：90%
下载进度：100%
图片下载完毕！！
图片显示完毕

7.守护线程setDaemon（boolean a）

守护线程（后台线程）：

1.守护线程又称为后台线程，默认创建的线程都不是后台线程，守护线程需要调用线程提供的方法void setDaemon（ boolean b）,当参数为true时，线程变为守护线程。

2.守护线程和普通线程上在使用上没有什么区别，但是结束时有一个区别：

当进程结束时，所有正在运行的守护线程会强制结束，也就是说，也就是说,普通线程结束时，守护线程会强制结束。

案例：模拟泰坦尼克号情景剧
public class DaemonThread {
	public static void main(String[] args) {
		//线程1（rose）
		Thread rose=new Thread(){
			public void run(){
				for(int i=0;i<10;i++){
					System.out.println("rose: 让我去死。");
					try {
						sleep(1000);
					} catch (InterruptedException e) {
						// TODO Auto-generated catch block
						e.printStackTrace();
					}
				}
				System.out.println("rose:扑通。。。");
			}
		};
		
		
		//线程2（jack）
		Thread jack=new Thread(){
			public void run(){
				while(true){
					System.out.println("jack:你死我也死！！！");
					try {
						sleep(1000);
					} catch (InterruptedException e) {
						// TODO Auto-generated catch block
						e.printStackTrace();
					}
				}
			}
		};
		
		//给jack设置成守护线程（后台线程）
		//设置守护线程在start方法之前方法前调用
		jack.setDaemon(true);
		rose.start();
		jack.start();
	}
}
运行结果：

jack:你die我也die！！！
rose: 让我去die。
rose: 让我去die。
jack:你die我也die！！！
rose: 让我去die。
jack:你die我也die！！！
rose: 让我去die。
jack:你die我也die！！！
rose: 让我去die。
jack:你die我也die！！！
jack:你die我也die！！！
rose:扑通。。。

从上面的运行可以看出当rose不再说话了，jeck也不说话了，说明rose线程结束，jack线程也跟着结束了。

8.查看线程的相关方法

public class InforDemo {
	public static void main(String[] args) {
		//获取该方法的线程信息
		Thread main=Thread.currentThread();
		System.out.println(main);
		//获取线程id
		long id=main.getId();
		System.out.println(id);
		//获取线程名字
		String name=main.getName();
		System.out.println(name);
		
		//获取线程的优先级
		int p=main.getPriority();
		System.out.println(p);
		
		//判断线程是否还活着
		boolean b=main.isAlive();
		System.out.println(b);
		
		//判断线程是否是后台线程
		boolean b1=main.isDaemon();
		System.out.println(b1);
		
		//判断线程是否被中断
		boolean b2=main.isInterrupted();
		System.out.println(b2);
	}
}

9.线程池

线程池主要完成工作：
1.管理多线程数量，由于多个每个线程会占用一定的内存，线程数量过多会导致内存占用过大，还有个问题就是cpu过度切换会导致程序（避免浪费资源）出现卡顿。
2.重用线程。

public class ThreadPool {
	public static void main(String[] args) {
		//创建线程池
		ExecutorService pool=Executors.newFixedThreadPool(2);
		for(int i=0;i<10;i++){
			//10个任务
			Runnable runn=new Runnable() {
				public void run() {
					String name=Thread.currentThread().getName();
					System.out.println(name+"正在执行任务。。。");
					try {
						Thread.sleep(2000);
					} catch (InterruptedException e) {
						// TODO Auto-generated catch block
						e.printStackTrace();
					}
				}
			};
			//将线程任务指定给线程池
			pool.execute(runn);
		}
		/*
		 * shutdown()与shutdownNow（）都是线程池停止状态
		 * shutdown（）方法调用后，线程池不再接受新任务，会将已有的任务全部执行后再停止
		 * shutdownNow（）调用后，线程池会调用所有线程的中断方法后立即停止
		 */
		pool.shutdown();
	}
}
运行结果：

会有两个线程来一起执行任务，大大降低的运行时间，提高了运行效率。

521125LYC
关注
JavaSE 学习参考：Runnable接口实现线程任务
bwf_erg的博客
03-25 336
Runnable接口 前面已经提到过通过继承Thread类创建线程，将线程的任务定义在重写的run方法即可。但是由于Java是单继承机制，假如某个业务类已经继承了一个父类同时有希望作为一个线程类，这样就无法再继承Thread类了，不过Thread类在设计时提供了一个插件机制来让我们通过插件的方式来实现线程。这个所谓的插件机制就是通过向外公开接口，来实现线程功能。先了解一下Thread类源码:
Java 线程的创建方式【总结】
单枪匹码
08-26 1329
线程是并发运行代码的，有如下几种创建方式： 1、继承Thread类并重写run方法： run方法中就是希望线程执行的逻辑，启动线程要调用start方法，而不是直接调用run方法，当start方法调用完毕后，run方法很快会被线程自行调用。 第一种创建线程的方式比较简单直接，但是缺点主要有两个： 由于需要继承线程，这导致不能再继承其他类，实际开发中经常要复用某个超类的功能，那么在继承线程后不能再继承其他类会有很多不便。 定义线程类的同时重写了run方法，这会导致线程与线程要执行的任务有一个必然的耦合关系，不
Java中常见的创建线程的方法
我以我心Coding You
03-19 270
方法一：继承Thread并重写run方法来定义线程要执行的任务。 package day09; /** * 第一种创建线程的方式 * 继承Thread并重写run方法来定义线程要执行的任务。 * @author kaixu * */ public class ThreadDemo1 { public static void main(String[] args) { MyThre...
java多线程实现runnable接口_通过实现Runnable接口实现多线程
weixin_39650139的博客
02-16 627
实现Runnable接口也是一种常见的创建线程的方式。使用接口的方式可以让我们的程序降低耦合度。Runnable接口中仅仅定义了一个方法，就是run。我们来看一下Runnable接口的代码。packagejava.lang;@FunctionalInterfacepublicinterfaceRunnable{publicabstractvoidrun();}其实Runnable就是...
线程 Runable重写run方法
weixin_43989380的博客
01-14 4791
创建线程方式二 java.lang.Runnable Runnable种没有start()方法，但创建的实现类对象可以调用start()方法 1.定义Runnable接口的实现类，并需要重写run（)方法，该run()方法的方法体同样时该线程的线程执行体。 2.创建Runnable实现类的实例，并以此为实例做Thread的target来创建Thread对象，该Thread对象才是真正的线程对象。 ...
Java多线程基础
m0_62946761的博客
05-17 3307
Java多线程基础知识
Java多线程基础知识
gldzzznb的博客
04-10 3361
这是我再次学习多线程知识的一个总结，对于刚刚接触的学习者是比较友好易懂的，便于快速的理解和掌握。
Java多线程基础（一）
计蒙不吃鱼的博客
07-19 5887
文章分两份，第一份主要内容为1-4点 1.多线程的概念 2.Java程序运行原理 3.实现多线程的2种方式 4.2种方式的区别 5.线程同步（同步锁） 6.同步线程之间的通讯 1.多线程的概念 （1）并发和并行 并行：多个CPU实例或是多台机器同时执行一段处理逻辑，是真正的同时。 并发：通过CUP调度算法，让用户看上去同时去执行，实际上从CPU操作层面并不是真正的同时。并发往往需要公共的资源，...
Java多线程干货系列（1）Java多线程基础编程开发技术
11-22
Java多线程是Java编程中的重要...以上内容仅涵盖了Java多线程基础编程的一部分知识点，实际开发中还需要关注更多的并发控制策略、性能优化和调试技巧。对于深入理解Java多线程，还需要学习和实践更多相关的高级特性。
Java多线程基础-01、数组概述.rar
11-20
本资料“Java多线程基础-01、数组概述”将带你入门Java的多线程世界，并结合数组这一基本数据结构进行讲解。 首先，我们需要理解什么是线程。线程是操作系统分配CPU时间的基本单位，一个进程可以有多个线程，它们...
Java 多线程基础笔记
08-17
Java 多线程基础笔记
Java多线程基础-03、数组定义方式二、元素默认值规则.rar
11-20
总之，Java多线程基础是高效编程的关键，而理解数组定义和元素默认值规则则是构建安全、健壮的多线程程序的基础。通过合理运用多线程技术和掌握数组的内在特性，你可以编写出更加高性能、可扩展的Java应用程序。
一篇文章弄懂Java多线程基础和Java内存模型
12-21
Java多线程是并发编程的重要组成部分，理解和掌握其基础以及Java内存模型对于任何Java开发者来说都是必不可少的。本文将深入探讨这两个主题。 首先，我们来理解多线程的生命周期及其五种基本状态： 1. 新建状态...
工厂模式的介绍及实现
户伟伟的博客
09-25 101
工厂模式（Factory Pattern）是一种创建型设计模式，提供了一种创建对象的接口，而无需显式指定对象的具体类。在这种模式中，我们通过定义一个工厂类，专门负责生产各种类型的对象，这样我们可以避免直接在代码中实例化具体类，使代码更具扩展性、灵活性和维护性。解耦：客户端代码与具体的类解耦，避免了对象创建逻辑的重复。简化对象创建：通过工厂统一管理对象的创建逻辑，使代码更清晰易懂。扩展性强：新增类时，只需在工厂中增加创建逻辑，而不必修改现有的业务代码。
基于Hive和Hadoop的哔哩哔哩网站分析系统
最新发布
图南的博客
09-27 229
本项目是一个基于大数据技术的哔哩哔哩平台分析系统，旨在为用户提供全面的哔哩哔哩视频数据和深入的用户行为分析。系统采用 Hadoop 平台进行大规模数据存储和处理，利用 MapReduce 进行数据分析和处理，通过 Sqoop 实现数据的导入导出，以 Spark 为核心进行高效的数据处理。整个系统结合了大数据处理技术，为用户提供精准的内容推荐和深入的用户兴趣分析，帮助平台更好地了解视频趋势和用户需求。
基于JavaWeb开发的Java+SpringMvc+vue+element实现驾校管理系统详细设计
央顺科技官方博客
09-24 846
机遇与挑战始终并存。在开放的互联网平台面前，驾校预约管理系统的信息管理面临着巨大的挑战。传统的管理模式局限于简单数据的管理，无法适应不断变化的市场格局。在早期阶段，在将计算机技术和网络技术融入驾校预约管理系统数据管理方法之前，所有管理方式都通过人工操作完成了管理信息的。系统管理也都将通过计算机进行整体智能化操作，对于驾校预约管理系统所牵扯的管理及数据保存都是非常多的，举例像所有详细信息包括，管理员；首页、个人中心、学员管理、驾校教练管理、驾校车辆管理、预约管理、取消预约管理、驾校公告管理、系统管理。
智能BI平台项目
2302_79400545的博客
09-22 227
BI商业智能：数据可视化、报表可视化系统。
Java Alibaba Druid 数据库连接池
miracle的专栏
09-24 724
在Java开发中，数据库连接池是性能优化的重要一环。而作为一款强大的数据库连接池解决方案，凭借其和对多种数据库的支持，成为了许多企业级应用的首选。本篇文章将介绍Druid的核心特性，并结合不同数据库的实际用法。
JPA+Thymeleaf增删改查
y050505的博客
09-25 453
在使用JPA（Java Persistence API）和Thymeleaf作为模板引擎进行Web开发时，实现增删改查（CRUD）操作是一个常见的需求。下面，我将简要介绍如何使用Spring Boot框架结合JPA和Thymeleaf来实现这一功能。
Java多线程基础与实战
本文旨在介绍Java多线程的基础知识，包括线程的实现方式、线程同步以及线程状态等核心概念。" 在Java中，线程是一个程序执行的最小单元，它代表了进程中的单一控制流。与进程相比，线程更加轻量级，因为它们共享...
评论 9
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值