Java之多线程详解

最新推荐文章于 2024-08-12 14:47:42 发布
最新推荐文章于 2024-08-12 14:47:42 发布
阅读量199 收藏
点赞数
分类专栏： Java 文章标签： JAVA 多线程 同步代码块 死锁 并发
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_41910103/article/details/83757198
版权

1.什么是多线程？
线程其实就是程序执行的一条路径 一个进程可以包含多个线程
多线程是并发进行的
底层 其实还是单线程（cpu运行效率极其高 ）
并发：两个任务同时请求运行 而处理器只能执行一个 不过由于处理的特别快感觉是两个任务同时运行
并行：就是两个任务一起同步运行（需要多核cpu）

2.java程序运行原理
jvm是多线程的 有两个线程： 垃圾回收线程 主函数main是个线程

3.Thread类
继承Thread
重写run 方法
调用start方法

public class Main{ 
	public static void main(String args[]) throws Exception{
		 
		 MyThread mt = new MyThread();
		 mt.start();
		 
		 for(int i=1;i<=1000;i++) {
			 System.out.println("主线程代码");
		 }
	 }
}
class MyThread extends Thread{
	public void run()
	{
		for(int i=1;i<=1000;i++) {
			 
			System.out.println("我的线程代码");
		 }
	}
}

4.实现Runnable
实现Runnable接口
重写run方法
因为要启动线程必须通过Thread类的start方法才能使用！
所以必须要创建Thread的对象 把Runable作为target参数传递给Thread

public class Main{ 
	public static void main(String args[]) {
		demo de = new demo();
		new Thread(de).start();    //1.第一种启动线程的方法  匿名对象
		
		Thread t = new Thread(de); //2.第二种启动线程的方法
		t.start();
		
		Runnable run = de;         //3.第三种启动线程的方法 父类引用指向子类对象
		new Thread(run).start();

		for(int i=1;i<=1000;i++) {
			 System.out.println("主线程代码");
		 }
	}
}
class demo implements Runnable
{
	@Override
	public void run() {
		for(int i=1;i<=1000;i++) {
			 System.out.println("我的线程代码");
		 }
	}
}

Runnable能够实现多线程的原理 （源码分析）
通过作为Thread类的构造参数 传入底层的init方法 最后给Runnable 类型的target赋值 然后去调用run方法

两者的区别：
1.继承 代码比较简单 不过有父类的话就不用了
2.实现 代码比较复杂 可以多实现
个人而言喜欢使用Runnable接口 扩展性比较强
当然具体情况具体分析

6.用匿名内部类实现多线程

public class Main{ 
	public static void main(String args[]) {
		new Thread() {
			public void run()
			{
				for(int i=1;i<=1000;i++) {
					 System.out.println("线程1111111111代码");
				 }
			}
		}.start();
		
		new Thread(new Runnable() {
			public void run()
			{
				for(int i=1;i<=1000;i++) {
					 System.out.println("线程33333333333代码");
				 }
			}
		}).start();
	}	
}

7.Thread的常用方法
1.给线程设置名字

public class Main{ 
	public static void main(String args[]) {
		
		//1.通过String name的构造来取名字
		new Thread("线程1") {
			public void run()
			{
					 System.out.println(this.getName()+"...线程1111111111代码");
			}
		}.start();
		
		new Thread("线程2") {
			public void run()
			{
					 System.out.println(this.getName()+"...线程2222222222代码");
			}
		}.start();
		
		//2.通过Thread类的setName方法
		new Thread() {
			public void run()
			{
				 this.setName("线程3");
				 System.out.println(this.getName()+"...线程33333333代码");
			}
		}.start();
		
		Thread t1 = new Thread() {
			public void run()
			{
					 System.out.println(this.getName()+"...线程4444444代码");
			}
		};
		t1.setName("线程4");
		t1.start();
	}	
}
}

2.获取当前线程的引用

public class Main{ 
	public static void main(String args[]) {
		
		new Thread(new Runnable() {
			
			@Override
			public void run() {
				System.out.println(Thread.currentThread().getName()+"...线程111111");
			}
		}).start();
		
		System.out.println(Thread.currentThread().getName()+"...线程222222");
	}
}

3.休眠线程
异常处理只能自己处理
因为父类的run方法没有抛出 所以子类的方法一定不能抛出！！
sleep方法是自行调用处理
wait方法是必须由别人调用才能处理

public class Main{ 
	public static void main(String args[]) {
		//倒计时器 
		new Thread() {
			@Override
			public void run() {
				
				for(int i=10;i>0;i--) {
					try {
						Thread.sleep(1000);
					} catch (InterruptedException e) {
						e.printStackTrace();
					}
					System.out.println("倒计时"+i+"秒");
				}
			}
		}.start();
	}
}

4.守护线程
守护线程就是例如象棋中的车马炮
而被守护的线程就是象棋中的帅 如果当帅的线程结束了 那么整个守护线程就立马结束（但是实际情况中是守护线程还是会执行一下 有遗留的数据要处理）
本demo中 t1为非守护线程

public class Main{ 
	public static void main(String args[]) {
		Thread t1 = new Thread() {
			@Override
			public void run() {
				
				for(int i=2;i>0;i--) {
					System.out.println("线程1....111");
				}
			}
		};
		
		Thread t2 = new Thread() {
			@Override
			public void run() {
				
				for(int i=10;i>0;i--) {
					System.out.println("线程2....222");
				}
			}
		};
		
		t2.setDaemon(true);
		t1.start();
		t2.start();
	}
}

5.加入线程
相当于插队 ！
就是线程1在运行的时候 线程2插队进来 等线程2结束后 线程1才继续执行
匿名内部类在使用所在方法中的局部变量时该变量必须要使用final修饰！或者事实上为final的

public class Main{ 
	public static void main(String args[]) {
		Thread t1 = new Thread() {
			@Override
			public void run() {
				
				for(int i=10;i>0;i--) {
					System.out.println("线程1....1111111111111111");
				}
			}
		};
		
		Thread t2 = new Thread() {
			@Override
			public void run() {
				
				for(int i=10;i>0;i--) {
					if(i==8) {
						try {
							t1.join(); //t1进来插队
							//t1.join(1); //t1进来插队 1毫秒以后  t1 t2又继续交替运行
						} catch (InterruptedException e) {
							// TODO Auto-generated catch block
							e.printStackTrace();
						}
					}
					System.out.println("线程2....222");
				}
			}
		};
		
		t1.start();
		t2.start();
	}
}

6.礼让线程
效果不是很明显 了解即可
7.设置线程的优先级
效果也不是很明显

public class Main{ 
	public static void main(String args[]) {
		Thread t1 = new Thread() {
			@Override
			public void run() {
				
				for(int i=100;i>0;i--) {
					System.out.println("线程1....1111111111111111");
				}
			}
		};
		Thread t2 = new Thread() {
			@Override
			public void run() {
				
				for(int i=100;i>0;i--) {
					System.out.println("线程2....22");
				}
			}
		};
		t1.setPriority(Thread.MAX_PRIORITY);
		t2.setPriority(Thread.MIN_PRIORITY);
		
		t1.start();
		t2.start();
	}
}

8.同步代码块
锁要一致
好处是 在每个任务的多条执行命令下不会错乱 线程之间的逻辑不会相互影响 造成乱码或者错误异常
例如本demo中的打印可能会出现 打印不正确的情况 虽然概率低不过存在
为了保证以上错误不会出现 所以要加锁！保证线程安全

public class Demo1_Synchronized {

	/**
	 * @param args
	 * 同步代码块
	 */
	public static void main(String[] args) {
		final Printer p = new Printer();
		
		new Thread() {
			public void run() {
				while(true) {
					p.print1();
				}
			}
		}.start();
		
		new Thread() {
			public void run() {
				while(true) {
					p.print2();
				}
			}
		}.start();
	}

}

class Printer {
	Demo d = new Demo();
	public void print1() {
		//synchronized(new Demo()) {							//同步代码块,锁机制,锁对象可以是任意的
		synchronized(d) {
			System.out.print("黑");
			System.out.print("马");
			System.out.print("程");
			System.out.print("序");
			System.out.print("员");
			System.out.print("\r\n");
		}
	}
	
	public void print2() {
		//synchronized(new Demo()) {							//锁对象不能用匿名对象,因为匿名对象不是同一个对象
		synchronized(d) {		
			System.out.print("传");
			System.out.print("智");
			System.out.print("播");
			System.out.print("客");
			System.out.print("\r\n");
		}
	}
}

class Demo{}

使用静态同步方法

class Printer2 {
	Demo d = new Demo();
	//非静态的同步方法的锁对象是神马?
	//答:非静态的同步方法的锁对象是this
	//静态的同步方法的锁对象是什么?
	//是该类的字节码对象
	public static synchronized void print1() {							//同步方法只需要在方法上加synchronized关键字即可
		System.out.print("黑");
		System.out.print("马");
		System.out.print("程");
		System.out.print("序");
		System.out.print("员");
		System.out.print("\r\n");
	}
	
	public static void print2() {
		//synchronized(new Demo()) {							//锁对象不能用匿名对象,因为匿名对象不是同一个对象
		synchronized(Printer2.class) {		
			System.out.print("传");
			System.out.print("智");
			System.out.print("播");
			System.out.print("客");
			System.out.print("\r\n");
		}
	}
}

使用非静态同步方法

class Printer2 {
	Demo d = new Demo();
	//非静态的同步方法的锁对象是神马?
	//答:非静态的同步方法的锁对象是this
	//静态的同步方法的锁对象是什么?
	//是该类的字节码对象
	public  synchronized void print1() {							//同步方法只需要在方法上加synchronized关键字即可
		System.out.print("黑");
		System.out.print("马");
		System.out.print("程");
		System.out.print("序");
		System.out.print("员");
		System.out.print("\r\n");
	}
	
	public  void print2() {
		//synchronized(new Demo()) {							//锁对象不能用匿名对象,因为匿名对象不是同一个对象
		synchronized(this) {		
			System.out.print("传");
			System.out.print("智");
			System.out.print("播");
			System.out.print("客");
			System.out.print("\r\n");
		}
	}
}

9.线程安全问题
第一种用Thread类继承

public class Demo3_Ticket {

	/**
	 * 需求:铁路售票,一共100张,通过四个窗口卖完.
	 */
	public static void main(String[] args) {
		new Ticket().start();
		new Ticket().start();
		new Ticket().start();
		new Ticket().start();
	}

}

class Ticket extends Thread {
	private static int ticket = 100;    //静态共享
	//private static Object obj = new Object();		//如果用引用数据类型成员变量当作锁对象,必须是静态的
	public void run() {
		while(true) {
			synchronized(Ticket.class) {
				if(ticket <= 0) {
					break;
				}
				try {
					Thread.sleep(10);				//线程1睡,线程2睡,线程3睡,线程4睡
				} catch (InterruptedException e) {
					
					e.printStackTrace();
				}
				System.out.println(getName() + "...这是第" + ticket-- + "号票");
			}
		}
	}
}

第二种用Runnable

public class Demo4_Ticket {

	/**
	 * @param args
	 * 火车站卖票的例子用实现Runnable接口
	 */
	public static void main(String[] args) {
		MyTicket mt = new MyTicket();
		new Thread(mt).start();
		new Thread(mt).start();
		new Thread(mt).start();
		new Thread(mt).start();
		
		/*Thread t1 = new Thread(mt);				//多次启动一个线程是非法的
		t1.start();
		t1.start();
		t1.start();
		t1.start();*/
	}

}

class MyTicket implements Runnable {
	private int tickets = 100;
	@Override
	public void run() {
		while(true) {
			synchronized(this) {
				if(tickets <= 0) {
					break;
				}
				try {
					Thread.sleep(10);				//线程1睡,线程2睡,线程3睡,线程4睡
				} catch (InterruptedException e) {
					
					e.printStackTrace();
				}
				System.out.println(Thread.currentThread().getName() + "...这是第" + tickets-- + "号票");
			}
		}
	}
}

10.多线程死锁问题
互相不肯释放
所以避免死锁 同步代码块不要嵌套

public class Demo5_DeadLock {

	/**
	 * @param args
	 */
	private static String s1 = "筷子左";
	private static String s2 = "筷子右";

	public static void main(String[] args) {
		new Thread() {
			public void run() {
				while(true) {
					synchronized(s1) {
						System.out.println(getName() + "...获取" + s1 + "等待" + s2);
						synchronized(s2) {
							System.out.println(getName() + "...拿到" + s2 + "开吃");
						}
					}
				}
			}
		}.start();
		
		new Thread() {
			public void run() {
				while(true) {
					synchronized(s2) {
						System.out.println(getName() + "...获取" + s2 + "等待" + s1);
						synchronized(s1) {
							System.out.println(getName() + "...拿到" + s1 + "开吃");
						}
					}
				}
			}
		}.start();
	}
}

Collections 可以调用方法始集合都可以变成线程安全
所以说Vector和Hashtable都被淘汰了
在这里插入图片描述

黑瞳丶
关注
专栏目录
多线程---狂神说java学习笔记
rzz65452064的博客
02-26 492
多线程详解 狂胜说java–多线程，bilibili视频地址 Java. Thread 目录 线程简介 线程实现（重点） 静态代理模式 Lambde表达式 线程状态 线程同步（重点） 线程通信问题 高级主题 一、线程简介 任务，进程，线程，多线程 任务 类似于干的事情 线程Thread 类似于道路。 普通方法调用：只有主线程一条执行路径。 （主程序→子程序→主程序） 多线程：多条执行路径，主线程和子线程并行交替执行。 （主程序→子程序） （ →主程序） 进程Process 操作系统中运行的程序就是
Java多线程详解及示例
07-20
Java多线程编程是提升程序性能和响应性的关键技术。理解多线程的概念，掌握线程的创建、同步、通信、死锁避免等核心知识点，以及合理使用线程池，对于编写高效、稳定的并发程序至关重要。通过实践，开发者可以更好地...
java多线程总结
weixin_33734785的博客
08-21 1256
（摘自）http://www.importnew.com/21089.html 引 如果对什么是线程、什么是进程仍存有疑惑，请先Google之，因为这两个概念不在本文的范围之内。 用多线程只有一个目的，那就是更好的利用cpu的资源，因为所有的多线程代码都可以用单线程来实现。说这个话其实只有一半对，因为反应“多角色”的 程序代码，最起码每个角色要给他一个线程吧，否则连实际场景都无法模拟，当然也...
多线程详细讲解(包含全部内容)
最新发布
qq_51263863的博客
08-12 817
包含了多线程从入门到精通的全部内容
Java多线程
执着的大笨猪的专栏
04-16 542
一、操作系统中线程和进程的概念现在的操作系统是多任务操作系统。多线程是实现多任务的一种方式。进程是指一个内存中运行的应用程序，每个进程都有自己独立的一块内存空间，一个进程中可以启动多个线程。比如在Windows系统中，一个运行的exe就是一个进程。线程是指进程中的一个执行流程，一个进程中可以运行多个线程。比如java.exe进程中可以运行很多线程。线程总是属于某个进程，进程中的多个线程共享进程的内存。“同时”执行是人的感觉，在线程之间实际上轮换执行。二、Java中的线程在Java中，“线程”指两件不同的事情
JavaSE--多线程
weixin_45632275的博客
08-14 144
1.概念： 程序(program)是为完成特定任务、用某种语言编写的一组指令的集合。即指一段静态的代码，静态对象。 进程(process)是程序的一次执行过程，或是正在运行的一个程序。是一个动态的过程:有它自身的产生、存在和消亡的过程。 - 如:运行中的QQ，运行中的MP3播放器 - 程序是静态的,进程是动态的 - 进程作为资源分配的单位，系统在运行时会为每个进程分配不同的内存区域 线程(thread)，进程可进一步细化为线程，是一个程序内部的一条执行路径。 - 若一个进程同一
Java 多线程详解
AReallyMan的博客
04-20 249
线程 线程的概念，百度是这样解释的： 线程（英语：Thread）是操作系统能够进行运算调度的最小单位。它被包含在进程之中，是进程中的实际运作单位。一条线程指的是进程中一个单一顺序的控制流，一个进程中可以并发多个线程，每条线程并行执行不同的任务。 在Unix System V及SunOS中也被称为轻量进程（Lightweight Processes），但轻量进程更多指内核线程（Kernel T...
Java多线程详解（超详细）_狂神说笔记完整版_项目代码_适合小白随课程学习
08-08
Java多线程详解 在Java编程中，多线程是一种重要的技术，它使得程序能够同时执行多个任务，提高系统的效率和响应性。本教程将详细讲解Java中的多线程概念，包括线程的创建、状态、同步以及高级主题，旨在帮助初学者...
Java多线程详解
01-20
文章目录1、进程与线程2、创建多线程2.1、继承Thread类2.2、实现Runnable接口2.3、使用匿名内部类实现2.4、实现Runnable接口的好处2.5、使用Callable和Future创建线程3、线程的生命周期4、几种特殊线程4.1、join线程...
详解Java多线程处理List数据
08-26
详解Java多线程处理List数据 Java多线程处理List数据是指在Java编程中，使用多线程技术来处理List数据的操作。这种操作可以提高程序的执行效率和性能，特别是在处理大规模数据时。下面将详细介绍Java多线程处理List...
Java多线程实战之单例模式与多线程的实例详解
08-26
Java多线程实战之单例模式与多线程的实例详解 单例模式是Java多线程编程中最常用的设计模式之一，它的主要作用是确保一个类在应用程序中只有一个实例，并提供一个全局访问点。单例模式有多种实现方式，如饿汉模式、...
java多线程详解
xyx328的博客
03-04 1228
多线程的实现方式
java多线程例子
热门推荐
优雅的IT之道
03-29 13万+
 这里我们做一个完整的例子来说明线程产生的方式不同而生成的线程的区别： package debug;import java.io.*;import java.lang.Thread;class MyThread extends Thread{ public int x = 0; public void run(){ System.out.println(++x); }}class
Java线程
weixin_33937778的博客
10-24 122
一、创建线程的两种方式 1. 继承Thread类 类 1) 定义子类继承Thread类。 2) 子类中重写Thread类中的run方法。 3) 创建Thread子类对象，即创建了线程对象。 4) 调用线程对象start方法：启动线程，调用run方法。 2. 实现Runnable 接口 1）定义子类，实现Ru...
java学习笔记_线程
今生今世的专栏
05-03 1041
一、Java线程：概念与原理 1、操作系统中线程和进程的概念 现在的操作系统是多任务操作系统。多线程是实现多任务的一种方式。进程是指一个内存中运行的应用程序，每个进程都有自己独立的一块内存空间，一个进程中可以启动多个线程。比如在Windows系统中，一个运行的exe就是一个进程。线程是指进程中的一个执行流程，一个进程中可以运行多个线程。比如java.exe进程中可以运行很多
Java多线程编程详解
"Java的多线程编程教程" 在Java编程中，多线程是一个重要的特性，它使得程序能够同时执行多个任务，提高了系统资源的利用率和程序的响应速度。本教程深入探讨了Java的多线程机制，由肖明教授在计算机学院讲解。 ...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

黑瞳丶

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值