当前位置：移动技术网 > IT编程>开发语言>Java > 多线程、同步工作原理、死锁案例、Lock接口、线程的生命周期的讲解及实现

多线程、同步工作原理、死锁案例、Lock接口、线程的生命周期的讲解及实现

2020年07月29日 | 移动技术网IT编程 | 我要评论

多线程

进程

正在运行的程序，称为进程，一个应用程序在内存中占用的资源才是进程

线程

线程:是进程中的某-功能开启了一条让CPU来执行路径，路径就是线程
线程就是一条路,CPU去内存中取出数据执行

线程的调度模型

每个线程都是具有优先级，优先级越高的线程，相对的会占用CPU的资源会更多，每个线程都是采用默认的优先级，轮流使用CPU资源，平均分配
设置线程的优先级，抢占

java中实现线程程序一

线程也是对象，对象都是由类创建
java.lang.Thread类，线程对象类

继承Thread类

实现步骤：

定义类继承Thread
子类重写方法run
创建子类的对象
调用方法start()启动线程

public class MyThread extends Thread{
	public void run() {
		for(inti=0;i<100;i++){
			System. out. print1n("子类重写方法run..."+i);
		}
	}
}
public static void main(string[] args) {
	//创建Thread类的子类对象
	MyThread my = new MyThread();
	//对象调用方法start()启动线程
	my. start();
	for(int i = 0 ;i< 100; i++) {
		system. out. print1n("main方法... "+i);
	}
}

线程的随机性

在这里插入图片描述

线程内存图

每次启动一个新的线程，就会创建出新的栈内存，运行方法run()
开启的线程越多，内存消耗越大，栈内存(线程栈，私有)
在这里插入图片描述

线程创建问题

为什么要继承Thread类
。Thread是线程对象，继承Thread，我们自己定义的类也是线程对象
为什么要重写run方法
。线程每次要运行什么程序，这是未知的，比如，程序运行循环，运行创建对象，运行IO复制
。sun公司：无论你要做什么事情，线程要完成的事情，都写着run()中
启动线程为什么不调用run()，调用start()
。start()启动线程，JVM调用run()
。start()方法最终执行的是start0()，是本地方法，c++写出来，和操作系统交互，启动线程是操作系统的事情

java中实现线程程序二

实现接口的方式

实现步骤：

定义类实现接口Runnable
重写方法run()
创建Thread类对象
。构造方法 Thread(Runnable target)传递Runnable接口实现类
调用Thread类方法start()方法

public class MyRunnable implements Runnable {
	pub1ic void run() {
		for(inti= 0 ;i< 100;1++) {
			System. out. print1n("实现类重写方法run..."+i);
		}
	}
}
public static void main(String[] args) {
	Runnable r = new MyRunnable();
	//创建Thread类对象,传递Runnable接口实现类对象
	Thread thread = new Thread(r) ;
	//Thread类方法start()启动线程
	thread. start( );
	for(int i=0;i<100;i++){
		System. out. print1n("main..."+i) ;
	}
}

两种实现线程的方式区别

单继承，继承方式实现线程，有局限性
接口实现，可以多现实，避免了单继承的局限性
继承方式，耦合性比较强，线程和线程要执行的任务耦合一起
接口实现，线程和线程任务的分离效果，低耦合，面向对象的思想

线程名字的操作

获取名字

每个线程都有自己的名字，默认的
Thread类，方法String getName()
线程的默认名字是：Thread-0 , Thread-1

public class MyThread extends Thread{
	public void run() {
	//直接调用父类的方法getName()
		System. out. println("继承重写方法. ."+super . getName());
	}
}
public static void main(String[] args) {
	MyThread my = new MyThread();
	my. start();
}

Thread类方法:

static Thread currentThread()返回当前线程对象
。当前线程静态方法写在哪个线程里面，哪个就是当前线程
Thread t = Thread. currentThread();获得线程名的通用方式

public static void main(String[] args) {
	//使用静态方法，获取当前线程对象
	Thread t = Thread. currentThread();
	System. out. println(t . getName()) ;
	MyThread my = new MyThread();
	my. start();
}

设置名字

Thread类，方法setName(String 线程名)
不建议修改线程名

线程安全

开发的是多线程的程序，如果出现了线程安全问题，程序人员是最大的责任人
安全问题产生：必须是多线程程序，争夺同一个资源

售票案例 jdk4.2

票源是固定值，常量，网络售票，现场自动售票，人工窗口
现场有3个人工窗口，同时售票

/*
*售票案例,引出线程的安全问题
*3个窗口同时售票工作，票是固定
*3个窗口看成三个线程，抢夺资源
*/
public class Ticket implements Runnable {
	//定 义100张
	private int tickets = 100;
	//线程调用的方法，售票工作
	public void run() {
	//票数是0的时候，停止
		while (true) {
			if(tickets > 0) {
				System. out . println("出售第"+tickets-- +"张");
			}
		}
	}
}
public static void main(String[] args) {
	//创建接口实现类对象
	Ticket ticket = new Ticket();
	//创建3个线程
	Thread t0 = new Thread( ticket );
	Thread t1 = new Thread( ticket );
	Thread t2 = new Thread( ticket );
	//启动线程
	t0.start();
	t1.start();
	t2.start();
}

Thread.sleep(long 毫秒)模拟出了，产生错误票的过程

public class Ticket implements Runnable {
	//定 义100张
	private int tickets = 100;
	//线程调用的方法,售票工作.
	public void run() {
		// 票数是o的时候，停止了
		while(true) {
			if(tickets > 0) {
				//线程休眠, Thread类的静态方法sleep
				try {
				Thread. sleep(5);
				}catch(Exception ex) {}
				System. out. print1n("出售第"+tickets-- +"张");
			}
		}
	}
}

解决安全问题

思想：当一个线程没有完成售票工作之前，其他的线程不能参与买票
同步技术：保证线程安全的解决办法

同步技术：
。关键字 synchronized
。任意对象
。线程操作的共享资源
同步的写法格式：

synchronized (任意对象){
	写的是线程操作的所有共享资源
}
同步代码块

public static void main(String[] args) {
	//创建接口实现类对象
	Ticket ticket = new Ticket();
	//创建3个线程
	Thread t0 = new Thread( ticket );
	Thread t1 = new Thread( ticket );
	Thread t2 = new Thread( ticket );
	//启动线程
	t0.start();
	t1.start();
	t2.start();
}
public class Ticket implements Runnable {
	//定 义100张
	private int tickets = 100;
	private Object obj = new Object();
		//线程调用的方法，售票工作
	public void run() {
			//票数是0的时候，停止了
		while(true) {
			synchronized( obj ) {
				if(tickets > 0) {
					//线程休眠, Thread类的静态方法s1eep
					try {
					Thread. sleep(5);
					}catch(Exception ex) {}
					System. out. println(Thread. currentThread() . getName()+ "出售第"+tickets-- +"张");
				}
			}
		}
	}
}

同步工作原理

就是把对象锁（唯一性）
线程判断锁，获取锁，释放锁，一旦线程安全，运行速度下降，必须牺牲速度，保证数据安全性
在这里插入图片描述

方法的优化

public class Ticket implements Runnable {
	//定义100张
	private int tickets = 100;
	private Object obj=new Object();
	public void run() {
		//调用售票的方法
		while(true) {
		saleTicket();
		}
	}
	//定义方法,专门处理售票tickets--
	public void saleTicket() {
		synchronized( obj ) {
			if(tickets > 0) {
				//线程休眠, Thread类的静态方法s1eep
				try {
				Thread. sleep(5);
				}catch(Exception ex) {}
				System. out. println(Thread. currentThread() . getName()+ "出售第"+tickets-- +"张");
			}
		}
	}
}
public static void main(String[] args) {
	//创建接口实现类对象
	Ticket ticket = new Ticket();
	//创建3个线程
	Thread t0 = new Thread( ticket );
	Thread t1 = new Thread( ticket );
	Thread t2 = new Thread( ticket );
	//启动线程
	t0.start();
	t1.start();
	t2.start();
}

方法saleTicket()出现了一个情况，整个的方法里面,所有程序都是线程操作的共享数据，不再使用同步代码块，可以同步整个方法

public class Ticket implements Runnable {
	//定义100张
	private int tickets = 100;
	public void run() {
		//调用售票的方法
		while(true) {
		saleTicket();
		}
	}
	//定义方法,专门处理售票tickets--
	public synchronized void saleTicket() {
		if(tickets > 0) {
			//线程休眠, Thread类的静态方法s1eep
			try {
			Thread. sleep(5);
			}catch(Exception ex) {}
			System. out. println(Thread. currentThread() . getName()+ "出售第"+tickets-- +"张");
		}
	}
}
public static void main(String[] args) {
	//创建接口实现类对象
	Ticket ticket = new Ticket();
	//创建3个线程
	Thread t0 = new Thread( ticket );
	Thread t1 = new Thread( ticket );
	Thread t2 = new Thread( ticket );
	//启动线程
	t0.start();
	t1.start();
	t2.start();
}

同步方法中也存在对象锁吗
同步方法中的锁，是当前对象的引用：this
静态的同步方法中，锁肯定不是this
是当前类的对象, Ticket.class文件也是对象
静态的同步方法中,锁对象是当前类的class文件对象
任何一个数据类型，都会有一个静态的属性，属性的名字是class

public static synchronized void saleTicket() {
	if(tickets > 0) {
		//线程休眠, Thread类的静态方法sleep
		try {
		Thread.sleep(5);
		}catch(Exception ex) {}
		System. out. print1n(Thread. currentThread() . getName()+ "出售第"+tickets--
		+"张");
	}
}

死锁案例

多个线程，在争抢同一个锁对象的时候，造成程序的假死现象

public class LockA{
	public static LockA Locka=new LockA();
}
public class LockB{
	public static LockB Lockb=new LockB();
}
public class DeadLock implements Runnable{
	//定义成员变量,控制线程的走向
	private boolean flag;
	public DeadLock(boolean flag) {
	this.flag =flag;
	}
	/*
	*实现死锁程序
	*/
	public void run() {
		while(true) {
			//判断flag=true
			//线程先进去A锁同步,在进入B锁同步
			if(flag) {
				synchronized ( LockA.locka ) {
					System. out. println("if. .locka锁");
					synchronized( LockB.lockb ) {
					System. out. println("if. .lockb锁");
					}
				}
			}
			else {
				synchronized ( LockB.lockb ) {
					System. out. println("if. .locka锁");
					synchronized( LockA.locka ) {
					System. out. println("if. .locka锁");
					}
				}
			}
		}
	}
}
public static void main(String[] args) {
	//创建 接口Runnable实现类,成员变量设置为true
	DeadLock d1 = new DeadLock(true);
	//创建接口Runnable实现类,成员变量设置为false
	DeadLock d2 = new DeadLock(false);
	new Thread(d1).start();
	new Thread(d2) . start();
}

匿名内部类实现线程

/*
*匿名内部类实现线程
*/
public static void main(String[] args) {
	/*Runnable r = new Runnable() {
		public void run() {
		System. out.println("线程开启");
		}
	};
	new Thread(r). start(); 
	*/
	new Thread( new Runnable() {
		public void run() {
		System. out. println("线程开启");
		}
	} ). start();

	new Thread() {
		public void run() {
		System. . out. println("子类继承父类" );
		}
	}. start();
}

Lock接口

JDK1.5出现的接口
java.util.concurrent.locks.Lock
替代synchronized，更加灵活

Lock接口的方法
。void lock()获取锁
。void unlock()释放锁
。实习类ReentrantLock

/*
*售票案例,引出线程的安全问题
*3个窗口同时售票工作，票是固定
*3个窗口看成三个线程，抢夺资源
*/
public class Ticket implements Runnable {
	//定 义100张
	private int tickets = 100;
	//创建Lock接口实现类对象
	private Lock lock= new ReentrantLock();
	//线程调用的方法，售票工作
	public void run() {
	//票数是0的时候，停止
		while (true) {
			//获取锁
			lock.1ock();
			if(tickets > 0) {
				//线程休眠, Thread类的静态方法sleep
				try{
					Thread. sleep(5);
				}catch(Exception ex) {}
				System. out . println(Thread . current Thread() . getName()+ " 出售第" +tickets-- +"张");
				//释放锁
			}
			lock . unlock();			
		}
	}
}
public static void main(String[] args) {
	//创建接口实现类对象
	Ticket ticket = new Ticket();
	//创建3个线程
	Thread t0 = new Thread( ticket );
	Thread t1 = new Thread( ticket );
	Thread t2 = new Thread( ticket );
	//启动线程
	t0.start();
	t1.start();
	t2.start();
}

线程的生命周期，线程的状态

线程在她的一生中，创建到死亡，经过多个状态
线程在某一个时刻，只能处于一种状态
共有6种状态
在这里插入图片描述

本文地址：https://blog.csdn.net/qq_45018290/article/details/107629112

您可能感兴趣的文章:

如对本文有疑问，点击进行留言回复！！

windows搭建flutter开发环境

近日在考虑用flutter开发app，为了少踩坑就网罗了一堆别人写的文章，然而实操发现还是没少踩坑，还是准备自己... [阅读全文]
Git如何在vscode中使用

VsCode中使用git准备条件：下载安装git，设置环境变量安装VsCode配置git设置全局配置git co... [阅读全文]
Gradle如何发布依赖库到公司（局域网）maven私服

上篇：Gradle发布共享库——Gradle发布本地maven库我们讲解了将类库发布到本地仓库后，我们可以方便... [阅读全文]
JAVA基础（Static关键字）

一.static定义属性---->所有对象共享同一属性：1.如果一个对象修改了Static属性，其他对象的... [阅读全文]
Android 4.0使用Kotlin调用C语言以及汇编语言

如今，Google早已将Kotlin编程语言作为了头等语言（first-class programming la... [阅读全文]
appium+python实现手机自动化爬虫B站热门番剧

我把灵异过程录下来了，速看！重大... [阅读全文]
爱奇艺随刻版邀请码是多少？爱奇艺随刻版怎么领会员？

爱奇艺随刻版邀请码是【k79nmv】或者【119743f】。欢迎大家填写哦！下面小编就来具体和大家说说爱奇艺随刻版邀请码是多少？爱奇艺随刻版怎么领会员？爱奇艺随... [阅读全文]
Java Method类及invoke方法原理解析

在说method和invoke的使用之前我们来看一个小例子，如果看懂了那就ok了public class methodinvoke { class anim... [阅读全文]
Java Class.forName()用法和newInstance()方法原理解析

class.forname()主要功能class.forname(xxx.xx.xx)返回的是一个类，class.forname(xxx.xx.xx)的作用是要... [阅读全文]
Spring如何基于注解显式实现自动装配

构建bean文件:public class people { private string name = "小明";}编写配置类:@configuration... [阅读全文]

网友评论


验证码：