【多线程】的学习

最新推荐文章于 2022-06-16 07:27:05 发布
最新推荐文章于 2022-06-16 07:27:05 发布
阅读量172 收藏
点赞数
文章标签： java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/Y_W_LIANG/article/details/109604946
版权
本文介绍了Java中线程的基本概念，包括进程与线程的区别，以及创建线程的四种方式，重点讲解了通过继承Thread类和实现Runnable接口创建线程的方法。此外，还详细讨论了线程同步的重要性，展示了如何使用synchronized关键字实现同步代码块和同步方法，以确保线程安全。最后，文章通过死锁的例子说明了线程同步不当可能导致的问题，并给出了避免死锁的策略。
摘要由CSDN通过智能技术生成

多线程

线程与进程的概念

在程序执行过程中，一个应用程序就是一个进程，在这个进行运行过程中可能根据不同的功能创建多个线程

创建线程

创建获取线程的方式有四种，但是常用方式两种

1)继承Thread类重写run方法

2)实现runnable接口实现run方法

jdk1.5以后额外新增两种方法

3)实现callable接口实现call方法

4)线程池创建

继承Thread类重写run方法

public class MyThread extends Thread {
	// 创建类继承thread
	// 类似于自己为指定任务创建了一个线程类
	String name;

	public MyThread(String name) {
		super();
		this.name = name;
	}

	@Override
	public void run() {
		for (int i = 1; i <= 10; i++) {
			System.out.println(name + ":" + i);
		}
	}

	public static void main(String[] args) {
		// 使用线程类创建完成指定功能的线程对象并调用
		MyThread mt = new MyThread("线程1");// 创建线程对象
		mt.start();// 启动线程

		MyThread mt2 = new MyThread("线程2");// 创建线程对象
		mt2.start();// 启动线程
	}
}

实现runnable接口实现run方法

//创建实现类实现runnable接口 实现run方法
public class MyRunnable implements Runnable {
	// 实现runnable类似于创建的是线程要执行的任务类
	// 需要创建线程并将任务交给线程执行
	@Override
	public void run() {
		// 书写要执行的功能
		for (int i = 1; i <= 10; i++) {
			System.out.println( i);
		}
	}
	
	
	public static void main(String[] args) {
		//首先创建任务对象
		MyRunnable mr=new MyRunnable();//要执行的任务对象
		//创建线程并将任务交由线程执行
		Thread t=new Thread(mr);
		t.start();
		Thread t1=new Thread(mr);
		t1.start();
	}
}

区别

本质上thread也实现了runnable接口，不同的是java中继承为单继承，并且多个对象间不能实现资源的共享.实现runnable接口虽然可以实现资源的共享但是如果多个线程执行不相干不同的任务使用继承thread类的形式有时更简单

使用继承thread类重写run方法的形式实现多个线程售票

public class MyThread extends Thread {
	// 创建类继承thread
	// 类似于自己为指定任务创建了一个线程类
	static int ticket = 5;
	// 当前类可以使用static修饰变量的形式实现共享，但是如果多个线程类就不能实现资源的共享了

	@Override
	public void run() {
		while (true) {
			if (ticket > 0) {
				System.out.println("买票" + ticket--);
			} else {
				System.out.println("票已售空");
				break;
			}
		}
	}

	public static void main(String[] args) {
		// 使用线程类创建完成指定功能的线程对象并调用
		MyThread mt = new MyThread();// 创建线程对象
		mt.start();// 启动线程

		MyThread mt2 = new MyThread();// 创建线程对象
		mt2.start();// 启动线程
	}
}

使用实现runnable接口重写run方法的形式实现多线程售票

//创建实现类实现runnable接口 实现run方法
public class MyRunnable implements Runnable {
	// 实现runnable类似于创建的是线程要执行的任务类
	// 需要创建线程并将任务交给线程执行
	int ticket = 5;

	@Override
	public void run() {
		// 书写要执行的功能
		while (true) {
			if (ticket > 0) {
				System.out.println("买票" + ticket--);
			} else {
				System.out.println("票已售空");
				break;
			}
		}
	}

	public static void main(String[] args) {
		// 首先创建任务对象
		MyRunnable mr = new MyRunnable();// 要执行的任务对象
		// 创建线程并将任务交由线程执行
		//多个不同的线程对象使用的同一个任务对象，所以任务对象中所有属性共享
		Thread t = new Thread(mr);
		t.start();
		Thread t1 = new Thread(mr);
		t1.start();
	}
}

常用方法

构造方法

Thread(Runnable target)
使用指定任务对象创建线程
Thread(Runnable target, String name)
使用指定任务对象指定名称创建线程

常用方法

String getName()
返回该线程的名称。 如果在创建线程时指定线程名则获取，否则根据创建顺序命名为Thread-0 向后递增

int getPriority()
返回线程的优先级。

void setPriority(int newPriority)
更改线程的优先级。

void setName(String name)
改变线程名称，使之与参数 name 相同。

void start()
使该线程开始执行；Java 虚拟机调用该线程的 run 方法。

static void sleep(long millis)
在指定的毫秒数内让当前正在执行的线程休眠（暂停执行），此操作受到系统计时器和调度程序精度和准确性的影响。

static Thread currentThread()
返回对当前正在执行的线程对象的引用

线程同步（线程安全）

在线程执行时，有可能在进行判断时多个线程使用相同变量进行判断，导致数据的不准确，从而导致最终结果与预期结果不符

多线程同步

多个线程同时运行使用同一资源是对于每个线程同步执行（需要在前一个线程使用完毕后下一个线程才能继续使用）

锁

在多线程同步时定义锁的概念，锁可以是一个对象或一个 方法，在线程执行时获取锁，执行介绍时释放，只有获取锁的线程可以执行否则进入等待

synchronized关键字

线程同步方法

在这里插入图片描述

同步代码块

使用同步关键字synchronized进行代码块的修饰，加入相应的对象作为锁

将需要同步执行的代码书写在同步代码块中

		synchronized (锁对象) {
   				 需要同步执行的代码块
		}

public class SynchronizedTest {
	public static void main(String[] args) {
		// MyR r = new MyR();
		// MyR r1 = new MyR();
		// Thread t1 = new Thread(r);
		// Thread t2 = new Thread(r1);
		// t1.start();
		// t2.start();

		MyT mt1 = new MyT();
		MyT mt2 = new MyT();
		mt1.start();
		mt2.start();
	}

}

class MyR implements Runnable {
	int t = 5;
	@Override
	public void run() {
		while (true) {
			synchronized (this) {//使用多个线程执行的任务对象当做锁对象
				if (t > 0) {
					System.out.println(Thread.currentThread().getName() + "正在做第" + t-- + "道题");
				} else {
					break;
				}
			}
		}
	}
}
class MyT extends Thread {
	static Integer t = 5;//将数据包装类当做锁对象
	@Override
	public void run() {
		while (true) {
			try {
				Thread.sleep(1000);
			} catch (InterruptedException e) {
				// TODO Auto-generated catch block
				e.printStackTrace();
			}
			synchronized (t) {
				if (t > 0) {
					System.out.println(Thread.currentThread().getName() + "正在做第" + t-- + "道题");
				} else {
					break;
				}
			}
		}
	}
}
同步方法

使用同步关键字synchronized进行方法的修饰，该方法的对象作为锁

//使用同步方法进行线程的同步
public class ThreadTest1 {
	public static void main(String[] args) {
		// MyRun mr1 = new MyRun();
		// Thread t1 = new Thread(mr1);
		// Thread t2 = new Thread(mr1);
		// t1.start();
		// t2.start();

		MyThr mt1 = new MyThr();
		MyThr mt2 = new MyThr();
		mt1.start();
		mt2.start();

	}
}

class MyRun implements Runnable {
	int t = 5;

	@Override
	public void run() {
		while (true) {
			try {
				Thread.sleep(1000);
			} catch (InterruptedException e) {
				// TODO Auto-generated catch block
				e.printStackTrace();
			}
			// 执行操作
			getT();
		}
	}

	// 使用同步关键字修饰方法
	public synchronized void getT() {
		// 在线程调用该方法是，获取该方法对象作为锁
		if (t > 0) {
			System.out.println(Thread.currentThread().getName() + "正在做第" + t-- + "道题");
		}
	}
}

class MyThr extends Thread {
	static int t = 5;

	@Override
	public void run() {
		while (true) {
			try {
				Thread.sleep(1000);
			} catch (InterruptedException e) {
				// TODO Auto-generated catch block
				e.printStackTrace();
			}
			// 执行操作
			getT();
		}
	}

	public static synchronized void getT() {
		// 在线程调用该方法是，获取该方法对象作为锁
		if (t > 0) {
			System.out.println(Thread.currentThread().getName() + "正在做第" + t-- + "道题");
		}
	}
}

死锁

当多个线程间使用多个锁资源，互相占用等待对方释放的过程

public class M {
	public static void main(String[] args) {
		Father f = new Father();
		Son s = new Son();
		FatherThread ft = new FatherThread(f, s);
		SonThread st = new SonThread(f, s);
		ft.start();
		st.start();
	}
}
//父类线程
class FatherThread extends Thread {
	Father f;
	Son s;
	public FatherThread(Father f, Son s) {
		super();
		this.f = f;
		this.s = s;
	}
	@Override
	public void run() {
		synchronized (f) {
			f.get();	 
			synchronized (s) {
				f.set();
			}
		}

	}
}
class SonThread extends Thread {
	Father f;
	Son s;
	public SonThread(Father f, Son s) {
		super();
		this.f = f;
		this.s = s;
	}
	@Override
	public void run() {
		synchronized (s) {
			s.get();
			synchronized (f) {
				s.set();
			}
		}

	}
}
class Father {
	public void get(){
		System.out.println("你给我成绩单,我给你玩具");
	}
	public void set(){
		System.out.println("给你玩具");
	}
}
class Son {
	public void get() {
		System.out.println("你给我玩具，我给你成绩单");
	}
	public void set() {
		System.out.println("给你成绩单");
	}
}
Y_W_LIANG
关注
多线程的使用
qq_43658407的博客
03-25 2046
1. 多线程 多任务执行,多路径执行 优点: 1.提高性能。 2.提高效率。 进程与线程之间的区别: 进程 : 系统中的程序,一个进程之间可以包含1~n个线程,系统中资源分配的最小单位,每个进程都有自己的代码与数据空间,进程之间的切换开销较大。 线程 : 程序中的顺序流,线程是cpu调度与执行的最小单位,多个线程之间共享进程的代码和数据空间,每一个线程都有自己的程序计数器运行栈,线程之间切换开销较小。 注意：一个cpu同一时刻只能调度一个线程。 创建线程的方式 : 1.继
多线程的运用
最新发布
weixin_47260194的博客
06-13 735
多线程是一种并发编程的方式，它允许程序在同一时间执行多个线程。线程是程序执行的最小单位，多个线程可以共享进程的资源（如内存、文件句柄等），但每个线程有自己的程序计数器、堆栈和局部变量。多线程的主要目的是提高程序的效率和响应速度。例如，在一个GUI应用程序中，如果你使用单线程来处理所有任务，界面可能会在执行耗时操作时被冻结。而使用多线程可以在执行耗时操作的同时保持界面的响应。多线程编程是Java开发中的一项重要技能，通过合理使用多线程，我们可以显著提升应用程序的性能和用户体验。
多线程的应用 多线程
重剑无锋，大巧不工。。。
07-24 1138
  多线程的应用：1.网络聊天工具开发  一个线程负责发消息，一个负责收消息。两者互不干扰，如果是单线程，那么就可能前面在等待，而后面就接收不了消息。2.大量数据库记录的复制。  如果一个复制要花3天时间，那么当你中途觉得没有必要，要停止的时候，你发现你不能让他停下来。而多线程的情况，一个  现成负责拷贝，是个无限循环  while(bStop)  {get data   copy dat
多线程的应用场景
热门推荐
03-06 5万+
多线程的应用场景
多线程使用
a136352的博客
12-28 228
多线程的创建方式： Java语言允许程序同时进行多个线程，主要通过java.lang.Thread类来体现。 方式一： 继承于Thread类，步骤：1.创建一个继承于Thread类的子类；2.重写Thread中的run()方法；3.创建Thread类的子类对象；4.通过此对象调用start()方法 不能通过run() public class ThreadTest { public static void main(String[] args) { PrimeThread p =
labview多线程学习
09-03
多线程学习在LabVIEW中的核心概念： 1. **线程与并行执行**：线程是程序中的执行单元，一个进程可以包含一个或多个线程。在LabVIEW中，多线程允许同时执行多个任务，实现程序的并行处理，提高系统的响应速度和整体...
Java多线程学习Java多线程学习Java多线程学习Java多线程学习.txt
05-15
Java多线程学习Java多线程学习Java多线程学习Java多线程学习Java多线程学习Java多线程学习Java多线程学习Java多线程学习Java多线程学习Java多线程学习Java多线程学习Java多线程学习Java多线程学习Java多线程学习Java...
java多线程学习
11-27
在学习Java多线程的过程中，理解线程与进程的概念是非常基础且重要的一步。首先，进程是一个程序的执行实例，是操作系统资源分配的基本单位，具有独立的地址空间和运行状态。每个进程至少包含一个线程，我们称之为...
C#多线程学习之(四)使用线程池进行多线程的自动管理
12-26
本文实例讲述了C#多线程学习之使用线程池进行多线程的自动管理。分享给大家供大家参考。具体如下： 在多线程的程序中，经常会出现两种情况： 一种情况： 应用程序中，线程把大部分的时间花费在等待状态，等待某个...
Java基础~Java线程通信
feizuiku0116的博客
03-15 472
一、介绍 所谓线程通信就是线程间相互发送数据，线程间共享一个资源即可实现线程通信。 二、常见形式 通过共享一个数据的方式实现。 根据共享数据的情况决定自己该怎么做，以及通知其他线程怎么做。 三、应用场景 生产者与消费者模型：生产者线程负责生产数据，消费者线程负责消费生产者产生的数据。 要求：生产者线程生产完数据后唤醒消费者，然后等待自己，消费者消费完该数据后唤醒生产者，然后等待自己。 线程通信的前提：线程通信通常是在多个线程操作同一个共享资源的时候需要进行通信，且要保证线程安全。
JavaSe学习笔记09（线程）
weixin_42845320的博客
12-04 602
JavaSe学习笔记 day05Thread中的常用方法创建线程的方式方式一：Thread创建多线程的方式二：实现Runnable接口创建线程的方式三：实现Callable接口。 --- JDK 5.0新增创建线程的方式四：使用线程池线程安全问题关于售票问题的思考同步机制，解决线程安全死锁线程通信 Thread中的常用方法 start():启动当前线程；调用当前线程的run() run(): 通常需要重写Thread类中的此方法，将创建的线程要执行的操作声明在此方法中 currentThread():静态
C#多线程学习之(一)多线程的相关概念分析
01-01
本文详细分析了C#多线程学习之多线程的相关概念。分享给大家供大家参考。具体分析如下： 什么是进程？ 当一个程序开始运行时，它就是一个进程，进程包括运行中的程序和程序所使用到的内存和系统资源。 而一个进程又...
多线程学习资源
02-05
多线程概述，past，coolie，多线程控制，多线程验证码
Java总结篇系列：Java多线程（一）
weixin_34228662的博客
06-30 426
多线程作为Java中很重要的一个知识点，在此还是有必要总结一下的。 一.线程的生命周期及五种基本状态 关于Java中线程的生命周期，首先看一下下面这张较为经典的图： 上图中基本上囊括了Java中多线程各重要知识点。掌握了上图中的各知识点，Java中的多线程也就基本上掌握了。主要包括： Java线程具有五中基本状态 新建状态（New）：当线程对象对创建后，即进入了新建状态，如：Thre...
Java 多线程
千樽醉的博客
12-14 125
进程与线程 进程是程序的一次动态执行过程，它需要经历从代码加载，代码执行到执行完毕的一个完整的过程，这个过程也是进程本身从产生，发展到最终消亡的过程。多进程操作系统能同时达运行多个进程（程序），由于 CPU 具备分时机制，所以每个进程都能循环获得自己的CPU 时间片。由于 CPU 执行速度非常快，使得所有程序好像是在同时运行一样。 多线程是实现并发机制的一种有效手段。进程和线程一样，都是实现并发的一个基本单位。线程是比进程更小的执行单位，线程是进程的基础之上进行进一步的划分。所谓多线程是指一个进程在执行过程
多线程的应用
m0_56056482的博客
06-16 892
线程的简单应用
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值