2019-7-18 [JavaSE] 线程-新建/就绪/运行/阻塞/死亡 主线程 子线程-三种运行 线程优先级 中断-sleep/join/yield 同步 锁 synchronized/lock

最新推荐文章于 2021-07-14 11:41:54 发布
最新推荐文章于 2021-07-14 11:41:54 发布
阅读量735 收藏
点赞数
分类专栏： java 文章标签： java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_45172861/article/details/96452661
版权

文章目录

1.线程

进程： 内存中运行的一个应用程序。
线程：进程中的执行流程
多线程： 一个进程中 由两个或两个以上这样的并发的执行流程。

2.线程状态

在这里插入图片描述
线程的生命周期：
在这里插入图片描述

1.新建

   Thread 或 Thread子类
   new  Thread();

2.就绪

 start()   
等待cpu的调用执行

3.运行

cpu调用执行了此线程。

4.阻塞

运行的线程 由于 某种原因 暂停了 cpu的调用执行。
1）sleep: 等待 （时间毫秒long）
线程A 调用了sleep()方法 ，那么线程A就处于了 阻塞状态， 当等待的时间超时了，
那么线程A才能恢复到 就绪状态 ，等待cpu调用执行，一旦cpu调用执行了，那么就
处于 运行状态。
join: 让一些线程先执行完
当t1 调用 join()方法了，那么 t2线程需要等待 t1线程都执行完 ，才能恢复到 就绪状态，
t2在等待的过程中就是阻塞状态。
2）同步
排队
3) wait 等待

5.死亡

3.线程

1.主线程

 最前 被 启动的线程 就是 主线程。
 主线程的任务 在 main()中。

2.子线程

任务在 ：run()中
在这里插入图片描述

方式一：继承Thread类

子线程的默认名称： Thread-0

class SubThread1 extends Thread{
	// 给子线程起名字
	SubThread1(String name){
		super(name);
	}
	@Override
	public void run() {
		for(int i = 1; i <= 3; i++) {
			System.out.println(Thread.currentThread().getName() + ": " + i);
		}
	}
}
public class TestSubThread1 {
	public static void main(String[] args) {
		//创建一个线程对象
		SubThread1 t1 = new SubThread1("t1");
		//启动一个线程
		t1.start(); 	
	}
}

方式二：实现Runnable接口

class SubThread2 implements Runnable{
	@Override
	public void run() {
		for(int i = 1; i <= 3; i++) {
			System.out.println(Thread.currentThread().getName() + ":" + i);
		}
	}	
}
public class TestSubThread2 {

	public static void main(String[] args) {
		// 
		SubThread2 st = new SubThread2();
		//创建一个线程
		Thread t = new Thread(st,"t1");
		t.start();
	}
}

方式三：实现Callable接口*

class SubThread3 implements Callable<Integer>{

	@Override
	public Integer call() throws Exception {
		int sum = 0;
		for(int i =1; i <= 3 ;i++) {
			System.out.println(Thread.currentThread().getName()+":" + i);
			sum += i;
		}
		return sum;
	}
}
public class TestSubThread3 {

	public static void main(String[] args) throws InterruptedException, ExecutionException {
		SubThread3 sub = new SubThread3();
		// 接收返回值
		FutureTask<Integer> f = new FutureTask<>(sub);
		//
		Thread t = new Thread(f,"tt");
		t.start();
		//获得返回结果
		System.out.println(f.get());	
	}
}

区别

1.继承Thread类 ，那么 这个类 就成为了一个线程类。
实现接口的其他两种方式 ，这个类本身不是线程类，需要借助Thread类创建线程。
2.实现接口的方式区别：
在这里插入图片描述

4.线程的优先级

在这里插入图片描述
1 - 10
1 - 最小的
10 - 最高的

设置优先级

//		t1.setPriority(1);
//		t2.setPriority(10);

t1.setPriority(Thread.MIN_PRIORITY);
t2.setPriority(Thread.MAX_PRIORITY);

5.方法

1.interrupt()线程中断

sleep()和join()

当t1 线程 被 t2线程中断了 ，那么 t1 线程 进入到异常处理。

class Thread1 implements Runnable{
	public void run() {
		for(int i = 1; i <= 10; i++) {
			if( i == 5 ) {
				try {
					Thread.sleep( 1000);
				} catch (InterruptedException e) {
					System.out.println(Thread.currentThread().getName()+"进入到了异常处理");
				}
			}
			System.out.println(Thread.currentThread().getName()+":" + i);
		}
	}
}
public class TestInterrupt {

	public static void main(String[] args) {
		Thread1 tr1 = new Thread1();
		Thread t1 = new Thread(tr1,"t1");
		t1.start();
		t1.interrupt();// 中断t1 
	}
}

2.yield() 线程让步（了解）

Thread.yield()

class Thread2 implements Runnable{
	public void run() {
		for(int i = 1; i <= 10; i++) {
			if( i == 5 && Thread.currentThread().getName().equals("t1") ) {
				Thread.yield();//让步
			}
			System.out.println(Thread.currentThread().getName()+":" + i);
		}
	}
}
public class TestYield {

	public static void main(String[] args) {
		Thread2 tr2 = new Thread2();
		Thread t1 = new Thread(tr2,"t1");
		Thread t2 = new Thread(tr2,"t2");
		
		t1.setPriority(1);
		t2.setPriority(10);
		
		t1.start();
		t2.start();
	}
}

6.线程同步

在这里插入图片描述
在这里插入图片描述

同步阻塞

1.获得锁

当线程 执行到 同步代码块 或 同步方法中的代码时，需要获得锁；

2.获得了锁

当线程A获得 锁成功，就可以执行同步代码块或同步方法中的代码了，
在执行的过程中，其他线程 是不能执行 此对象的同步代码块或同步方法中的代码，
但是 可以执行 其他 对象 的 同步代码块 或 同步方法的代码。

3.释放锁

1)同步代码块 或 同步方法的代码 正常执行完；
2)同步代码块 或 同步方法的代码 遇到了没有能处理的异常中断了程序；
3)同步代码块 或 同步方法的代码 return ,break;  结束了代码块或方法；
4)同步代码块 或 同步方法的代码 wait().

以上四种方式释放锁

法一
class Bank implements Runnable{
	private int money = 0;
	//存一次钱的方法 锁对象 this，synchronized在这里添加
	synchronized public void setMoney() {
		this.money  += 100;
		System.out.println(Thread.currentThread().getName()
				+ "存了100，余额：" + this.money);
	}
	public void run() {
		for(int i = 1; i <= 3; i++) {
				this.setMoney();			
		}
	}
}
public class TestBank {

	public static void main(String[] args) {
		Bank bank = new Bank();
		
		Thread zhangsan = new Thread(bank,"张三");
		Thread lisi = new Thread(bank,"李四");
		zhangsan.start();
		lisi.start();
	}
}
法二
class Bank implements Runnable{
	private int money = 0;
	private int count = 0;
	//存
	 public void setMoney() {
		this.money += 100;
		count ++;
		System.out.println(Thread.currentThread()
				.getName()+"剩"+money+","+count);
	}
	public void run() {
		for (int i = 1; i <= 3; i++) {
		//synchronized在这里添加
			synchronized (this) {
				this.setMoney();	
			}		
		}
	}
}

7.ReentrantLock

在这里插入图片描述

法一

class Bank1 implements Runnable{
	private int money = 0;
	// 公平锁
	ReentrantLock  lock = new ReentrantLock();
	//存一次钱的方法 锁对象 this
	public void setMoney() {
		try {
			lock.lock();// 获得锁
			this.money  += 100;
			System.out.println(Thread.currentThread().getName()
					+ "存了100，余额：" + this.money);
		}finally {
			lock.unlock();// 释放锁
		}
	}
	public void run() {
		for(int i = 1; i <= 3; i++) {
				this.setMoney();		
		}
	}
}
public class TestLock {

	public static void main(String[] args) {
		Bank1 bank = new Bank1();
		
		Thread zhangsan = new Thread(bank,"张三");
		Thread lisi = new Thread(bank,"李四");
		zhangsan.start();
		lisi.start();
	}
}

法二

class Bank implements Runnable{
	private int money = 0;
	private int count = 0;
	ReentrantLock lock = new ReentrantLock();
	//存
	 public void setMoney() {
		lock.lock();
		this.money += 100;
		count ++;
		System.out.println(Thread.currentThread()
				.getName()+"剩"+money+","+count);
		lock.unlock();
	}
	public void run() {
		for (int i = 1; i <= 3; i++) {
				this.setMoney();	
		}
	}
}

synchronized 和 Lock的区别

1.synchronized 是一个关键字 使用简单；
Lock 需要创建对象 ，显示获得锁 和 显示 释放锁；
2.synchronized 没有 明显的 获得锁 或 释放锁；
Lock可以 显示的获得锁和释放锁；
3.Lock 提供了更多的方法。提供了更多的功能。

8.编写：多线程

加粗样式

class SubThread5 implements Runnable{
	@Override
	public void run() {
		for(int i = 1; i <= 10; i++) {
			try {
				Thread.sleep(1000);
			} catch (InterruptedException e) {
				e.printStackTrace();
			}
			System.out.println(Thread.currentThread().getName() + ":" + i);
		}
	}	
}
public class TestSubThread5_exam {

	public static void main(String[] args) {
		SubThread5 sub = new SubThread5();
		new Thread(sub,"t1").start();
		new Thread(sub,"t2").start();
	}
}

9.注意：

1.Callable有返回值
2.在线程少时sy和lock一样，线程多的时候用lock可以提升性能

景子墨
关注
专栏目录
Java 多线程编程
weixin_41170125的博客
07-23 98
目录 概念 一个线程的生命周期 概念 Java 给多线程编程提供了内置的支持。 一条线程指的是进程中一个单一顺序的控制流，一个进程中可以并发多个线程，每条线程并行执行不同的任务。 多线程是多任务的一种特别的形式，但多线程使用了更小的资源开销。 这里定义和线程相关的另一个术语 - 进程：一个进程包括由操作系统分配的内存空间，包含一个或多个线程。一个线程不能独立的存在，它必须是进程的一部分。一个进程一直运行，直到所有的非守护线程都结束运行后才能结束。 多线程能满足程序员编写高效率的程序来达到充
JAVASE----基础（八）
zkw129的博客
12-26 244
多线程； 多线程安全
java多线程代码案例(创建线程,主线程,线程优先级,线程组,线程同步,线程间的通信)
03-31
java多线程知识点，源代码案例，代码案例中包括如何创建线程，主线程，线程优先级，线程组，线程同步，死锁，线程间的通信知识点
主线程与子线程的优先级问题
YuenBin128的博客
05-03 6382
在一个线程中开启另外一个新线程，则新开线程称为该线程的子线程，子线程初始优先级与父线程相同。不过主线程先启动占用了cpu资源，如果存在主线程和子线程争抢cpu执行权的话，看运气，谁抢到就让谁执行。其实设置了优先级，也无法保障线程的执行次序。只不过，优先级高的线程获取CPU资源的概率较大，优先级低的并非没机会执行。 线程的优先级用1-10之间的整数表示，数值越大优先级越高，默认的优先级为5。...
线程优先级
写写代码
02-20 143
许许多多的线程都有着它的优先级，理论上优先级越高越有可能执行，但不一定执行。Thread类中有定义如下处理优先级的方法： // 设置优先级 public final void setPriority(int newPriority) {} // 获取优先级 public final int getPriority() {} // 最低优先级，数值为1 public final static...
多线程中主线程与子线程执行的顺序
热门推荐
Maspue的博客
09-27 1万+
在我们刚刚接触多线程时，所练习的Demo可能会达不到我们期待的运行结果，这其实有两种可能： 第一，是巧合，CPU可能是一直执行完一个线程再去执行另一个线程。所以我们看到的结果一直是没有交替执行的。 解决办法是：把运行的次数放大，10次不行就100次，100次不行就1000次，1000次不行5000次，其实1000次的时候也就差不多出现了交替运行。 //线程任务类 public class Th...
Java学习之JavaSE-Java核心类库
bricklayer_hzc的博客
07-14 568
第一章：常用类的概述和使用 一、常用的包（熟悉） （一）包的名称和功能 java.lang包 - 该包是Java语言的核心包，并且该包中的所有内容由Java虚拟机自动导入。 如：System类、String类、… java.util包 - 该包是Java语言的工具包，里面提供了大量工具类以及集合类等。 如：Scanner类、Random类、List集合、… java.io包 - 该包是Java语言中的输入输出包，里面提供了大量读写文件相关的类等。 如：FileInputStream类、FileOutput
java面试宝典书籍-JavaSE基础
qq_28400629的博客
08-08 410
知识：java面试宝典 JavaSE基础注：知识都来源于Java面试宝典书籍，此处只为学习 一、Java面向对象 Standard Edition 1. 面向对象的特性以及理解 封装：将对象进行封装，封装后可以通过调用对象的方式调用对象的属性，使一切变得有序 继承：父类、子类，继承方法 多态：方法重写(修改方法里的内容)、方法重载(方式所携带的参数不同) 、对象造...
线程，看这一篇就够啦
w_rcss的博客
07-30 470
文章目录多线程一 进程和多线程进程线程并发和并行上下文切换CAS算法协程死锁为什么要使用多线程二 使用多线程2.1继承Thread类2.2实现Runnable接口2.3实现Callable接口，callable+futureTask2.4实现Callable接口，线程池+future三 线程的状态：新建状态 new就绪状态 runnable运行状态 running阻塞状态 blocked死亡状态 ...
设置优先级_了解Java线程优先级，更要知道对应操作系统的优先级，不然会踩坑...
weixin_28716181的博客
01-05 267
Java 多线程系列第 6 篇。这篇我们来看看 Java 线程的优先级。Java 线程优先级Thread 类中，使用如下属性来代表优先级。private int priority;我们可以通过 setPriority(int newPriority) 来设置新的优先级，通过 getPriority() 来获取线程的优先级。 有些资料通过下面的例子就得出了一个结论：~~Java 线程默认优先级是 ...
c++主线程和子线程
魏圣颖的博客
01-29 1万+
c++主线程和子线程 最近在学习c++多线程，写一篇博客记录下自己的收获。 一.main()函数是主线程函数，在main()函数中创建的线程属于子线程，那主线程和子线程的优先级谁更高呢？ 可以看下另外一篇文档：link 在一个线程中开启另外一个新线程，则新开线程称为该线程的子线程，子线程初始优先级与父线程相同。不过主线程先启动占用了cpu资源，如果存在主线程和子线程争抢cpu执行权的话，看运气，谁...
【Java】多线程其实可以设置优先级
程序猿开发日志【学习永无止境】
11-08 1739
Java优先级 Java提供一个线程调度器来监视和控制Runnable状态的线程。线程的调度策略采用抢占式，优先级高的线程比优先级低的线程优先执行。在优先级相同的情况下，按照“先到先服务”的原则。 每个Java程序都有一个默认的主线程，就是通过JVM启动的第一个线程。对于应用程序，主线程执行的是main()方法。对于Applet主线程是指浏览器加载并执行小应用程序的那一个线程。 子线程是由应...
多线程练习：线程的优先级
我们不创造代码
08-07 1797
题目：线程的优先级 需求说明： 1、显示主线程、子线程默认优先级 2、将主线程设置为最高优先级、子线程设置为最低优先级并显示 解题代码： public class Demo2{ public static void main(String[] args) { Thread.currentThread().getPriority(); Thread Thread_0 =new Thread(); Thread_0.getPriority();
Java线程优先级
Leon_ang的博客
05-22 417
*线程优先级用数字表示，范围1到10，缺省为5 * Thread.MIN_PRIORITY=1 * Thread.MAX_PRIORITY=10 * Thread.NORM_PRIORITY=5 * int getPriority();//获得对象优先级 * void setPriority(int newPriority);//设置对象优先级
线程
black mamba
10-10 151
怎么创建线程？ 创建线程的三种方式： 1.继承 Thread 类，重写 run() 2.实现 Runnable 接口 3.实现 Callable 接口，返回 FutureTask .get() 获取执行结果 线程的生命周期（线程的 6 种状态） 1. NEW - 初始状态 Thread t = new Thread(); 2. RUNNABLE - 运行状态 t.start();// 就绪状态 多个线程争抢 CPU 时间片，抢到后变为运行状态 时间片到期，变为就绪状态，再次参与时间
多线程的常用操作方法+根据程序运行结果分析主线程与子线程的执行顺序
weixin_41750142的博客
11-25 529
一、sleep方法：使线程暂停运行，并交出CPU,无需notify、notifyAll唤醒，等睡眠时间期满，就会“醒来”，不过这时该线程不一定拥有CPU，只有正在执行的线程停止运行，或者刚醒来的这个线程具有更高的优先级时，才会继续执行。 以下代码可说明这个问题： public class MyThread implements Runnable { public static void ma...
记一个主线程sleep导致子线程卡住事件
wf2397108372的博客
08-26 2071
话不多说直接上代码，主线程代码： public void Stop() { isAutoRead = false; while (isRunning) Thread.Sleep(100); } 子线程代码： private void LoopReadCard() { isRunning = true; CefCardReader r
【C#.37】多线程中的Sleep以及子线程优先级
huiwuhuiwu的专栏
12-11 1万+
继续上篇，其实在写文章的过程中真的实践了不少，而且发现和自己原来认为的有挺多不同的。因此有错误的话请多指正。以下的内容都是经过试验得出的： using System; using System.Threading; namespace Chapter1.Recipe2 { class Program { static void Main(string[] args) { Thread
32位Red Hat JDK-7u2 rpm下载与安装教程
本文档详细介绍了如何在32位Red Hat操作系统上下载和安装Java Development Kit (JDK) 版本7u2的Linux-i586.rpm格式安装包。对于使用Red Hat系统且需要开发环境的用户来说，这是一个关键的指南。 首先，文章的标题...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值