线程(同步)

最新推荐文章于 2023-07-14 07:15:00 发布

Ricardo_M_Zhou

最新推荐文章于 2023-07-14 07:15:00 发布

阅读量146

点赞数

分类专栏： java 文章标签：线程同步

本文链接：https://blog.csdn.net/Ricardo_M_Zhou/article/details/88832670

版权

java 专栏收录该内容

8 篇文章 0 订阅

订阅专栏

什么是线程

任务管理器可以有多个进程，每个进程运行的都是可执行程序，一个可执行程序就是一个软件，可执行程序的本质就是在计算机当中运行的一块代码
进程：可以看成是在计算机当中运行的一块代码
线程：可以看成是在计算机当中运行的一小块代码
2.3线程与进程的关系
一个进程中可以有多个线程，至少得有一个线程；
上面说一个进程可以狭隘的看成是一大段代码，那其实线程也是一段代码
线程是进程中的最小单位；
也可以把线程看成是一个轻量级的进程
注意常识 : 计算机安装一个软件，软件是由代码构成，当启动一个软件之后，代码被放入内存中，为什么会放入到内存中，因为内存的读写速度比较快，这时候CPU就开始处理内存当中的任务，也就是当前软件程序[ 代码 ]运行起来了。
2.4 CPU如何处理任务?
在单位时间时间片上只能执行一个线程
CPU看到内存中有很多的线程，CPU在单位时间片（时间片：很微小的时间单位）上高速切换线程执行
2.5多线程下载软件为什么快
问题:很多使用多线程技术开发的软件，下载速度比较快，例如，迅雷…某些软件，QQ影音，快播…迅雷影音等等…为什么下载速度会比较快

假设上面软件都是运行在同一台电脑上面，两款软件运行，肯定是由一个CPU在处理该任务
CPU处理任务最小单位是线程，CPU是通过资源分配的方式，在多个线程之间，以时间片（时间片：很微小的时间单位）为单位，高速切换内存中要执行的线程任务。
在同一个时间片上，只能处理一个线程
在CPU的眼中，只看到内存中有很多线程，大家都是平等的，获取到CPU处理的机会是均等的，CPU会平均分配资源给每一个线程
假设每个线程执行一分钟，快播软件占用CPU时间为三分钟，迅雷占用CPU处理任务的时间为1分钟，自然快播处理的任务会更多，下载的内容更多

2.6线程的作用

线程的作用：看下面两种理解方式：
①可以将代码中（软件）的某些独立的功能包装起来，单独作为任务交给CPU处理！
②将需做的某个功能封装成一个线程体，该线程可以独立的获得CPU分配的资源
从而实现多功能同时运行。

① 玩游戏的线程类
② 放音乐的线程类
③ 测试类：创建① ②的对象，然后调用start方法启动

代码清单：

public class PlayGameThread extends Thread{
public void run() {
for (int i = 0; i < 100; i++) {
System.out.println(“double kill…”);
}
}
}

public class MusicThread extends Thread{
public void run() {
for (int i = 0; i < 100; i++) {
System.out.println(“摩擦。。。摩擦…”);
}
}
}

public class Test {
public static void main(String[] args) {
PlayGameThread pgt = new PlayGameThread();
MusicThread mt = new MusicThread();
```
	pgt.start();
	mt.start();
}
```
}

3.4 小结：创建启动线程的方式一（继承Thread类）
1、先明确我们需要把什么事情封装成一个线程对象（现有相应的代码）
2、自定义一个类 extends Thread
3、覆写run方法，在这里写1步中的代码
4、创建一个自定义类的对象 t
5、启动线程 t.start();
6、注意执行过程：本质是代码执行到一个位置之后，如果切换到另一个线程，在切换回来，那么会从刚才切换走的代码位置继续执行：产生线程安全问题的原因，就在此…

3.4 注意事项
直接调用run方法和start的区别？

可以直接调用run方法，但是没有启动一个独立的线程；
只有调用start 才回启动一个独立的线程；
自己启动的线程和主线程有关系吗？
直接写一个最简单的hello word 程序，就有一个主线程
一个线程一旦启动就是独立的了，和创建启动它的环境没有直接的包含关系
代码清单：
public class Test2 {
/** 测试主线程执行完毕我们自定义的线程还是会继续执行（前提就是主线程完了，自定义的线程还没有执行完）*/
public static void main(String[] args) {
System.out.println(“hello…”);
new ThreadTest().start();
for (int i = 0; i < 100; i++) {
System.out.println(“main”+i);
}
}
}
class ThreadTest extends Thread{
public void run() {
for (int i = 0; i < 100; i++) {
System.out.println(“自定义线程”+i);
}
}
}

5.1 线程的创建启动方式
线程的作用

将需做的某个功能封装成一个线程体，该线程可以独立的获得CPU分配的资源
从而实现多功能同时运行。

Thread线程类本质是实现Runnable接口

通过查看API得知，Thread当中的run方法不是来自于自身，而是通过实现Runable接口里面的run方法，从而实现某个类的实例，可以通过线程的方式实现功能，类必须定义一个名为run的无参数方法
本质Thread也是通过实现接口来实现线程功能的
如果自定义一个类，完全可以是通过实现该接口从而，通过线程实现功能

自定义类通过实现Runable的方式来实现线程，如何启动

通过实现Runable实现线程的，自定义类，的对象A。放在一个空壳的Thread线程对象当中
然后通过该对象来调用start方法启动线程A

代码清单：

public class TicketThread implements Runnable{
private int num = 50;

public void run() {
	// 最终的代码
	while(num>0){
		System.out.println("您的票号是："+num);
		num--;
	}
}

}
public class Test {
public static void main(String[] args) {
/*
* 只需要创建一个TicketThread的对象 tt
* 以tt为参数来创建3个Thread对象
*/
TicketThread tt = new TicketThread();

	Thread t1 = new Thread(tt);
	Thread t2 = new Thread(tt);
	Thread t3 = new Thread(tt);
	
	t1.start();
	t2.start();
	t3.start();
}

}

问题：
为什么上面没有static，也只销售50张票左右，而没有销售150张，本质其实只创建了一个对象，在被三个线程对象共享
5.2 小结：实现方式启动线程的流程
1、明确线程主体（自己需要实现的代码）;
2、自定义一个类实现Runnable接口
3、覆写run方法：写第一步中的代码
4、创建一个自定义类的对象 t
5、以t为参数来构造一个Thread对象 tt;
Thread tt = new Thread(tt);
6、tt.start();//启动线程对象tt,对线程对象t 的主体代码进行访问
5.3 继承Thread 和实现Runnable的区别
1、继承有局限，Java中类只能够单继承
2、实现的方式，我们的类在业务上可以继承它本应该有的类，同时可以实现接口变成一个线程类
3、关于数据共享的问题：就看所谓被共享的数据所在的类的对象被创建了几个
6. Thread类
6.1 线程休眠sleep
什么是线程休眠

线程类Thread当中有一个static void sleep(long millis)方法，在指定的毫秒数内让当前正在执行的线程休眠

注意 : 当前正在执行的线程就是主线程
线程休眠应用

可以做倒计时
代码清单：
Frame f = new Frame();
Label label = new Label(“10”);
label.setBackground(Color.RED);
// 字体对象
Font font = new Font(“宋体”,Font.BOLD,666);
label.setFont(font);
label.setAlignment(Label.CENTER);
f.add(label);
```
f.setSize(780, 780);
f.setLocationRelativeTo(null);
f.setVisible(true);

for (int i = 10; i >= 0; i--) {
	label.setText(i+"");
	Thread.sleep(1000);
}
```
可以用来模拟网络延迟
6.2 线程的优先级
1.线程优先级概念：
每个线程[线程对象]都有一个优先级，高优先级线程的执行优先于低优先级线程（简单说：如果一个线程的优先级越高，获得CPU资源的机会更大，不等于高优先级的就最先执行）
2.如何设置优先级呢？调用方法
int getPriority() 返回线程的优先级
void setPriority(int newPriority) 更改线程的优先级

3.希望验证一下上面的理论

先通过主线程来测试获得和设置优先级
public static void main(String[] args) {
//获取主线程
Thread m = Thread.currentThread();
System.out.println(m.getPriority());//输出主线程优先级
m.setPriority(Thread.MAX_PRIORITY);//设置主线程优先级
System.out.println(m.getPriority());//输出主线程设置优先级之后的优先级
}
设置自己定义的线程的优先级
线程的默认优先级和创建它的环境线程的当前优先级一致，主线程的默认优先级是5
小结：

知道调用对应的方法来获得和设置线程的优先级
想办法测试高优先级的执行机会高于低优先级？
6.3 守护线程
什么守护线程

1、守护线程（精灵线程/后台线程）
①每个线程都可以或不可以标记为一个守护程序
②后台线程仅仅就是对线程的一个分类或者标记
2、特点：
① 一般来说后台线程是为前台线程服务的（例如gc线程）；
② 如果所有的前台线程都死了，那么后台线程也会自动的死亡；但是前台线程死了，后台线程不一定立即死亡（可能还需要收尸…）
③ 一个线程的默认状态和创建它的环境线程状态一致

测试把一个线程标记为守护线程

① 相关的方法：
boolean isDaemon() 测试该线程是否为守护线程
void setDaemon(boolean on) 将该线程标记为守护线程或用户线程
如果上面从参数为true 表示是后台线程
② 先以主线程来进行测试：1获得 2 尝试修改
③ 自定义的线程： 1 获得 2 尝试修改
3、小结
① 知道什么是守护线程
② 知道如何调用方法修改它的状态
③ 主线程不能够修改状态—》活动状态的线程是不能被修改的
package cn.itsource._07Deamon;

public class TestDeamon {
/*
* boolean isDaemon() 测试该线程是否为守护线程 :是否为后台
void setDaemon(boolean on) 将该线程标记为守护线程或用户线程

	1.启动的线程不修改为后台或者前台
	2.一个线程的是否为后台线程与创建的环境一致
 * */

public static void main(String[] args) {
	/*static Thread currentThread() 
    	返回对当前正在执行的线程对象的引用。 */
	Thread main = Thread.currentThread();
	boolean daemon = main.isDaemon();
	System.out.println(daemon);
	/*
	 * 修改主线程为后台线程
	 * 		启动的线程不能修改为后台或者前台线程
	 * */
	//main.setDaemon(true);
	//System.out.println(main.isDaemon());
	
	/* void setDaemon(boolean on) 
     	将该线程标记为守护线程或用户线程 */
	Thread th = new Thread();
	//th.start();启动的线程不能修改
	th.setDaemon(true);
	System.out.println(th.isDaemon());
	MyThread myThread = new MyThread();
	myThread.setDaemon(true);
	/*
	 * main主线程：执行完毕：主线程自然死亡
	 * 1.主线程死了：后台会自动死亡：自定义线程没有打印run方法里面的内容，因为自动死亡
	 * 2.也有可能会打印：因为后台不一定马上死
	 * */
	myThread.start();//后台线程启动，执行run方法里内容


}

}
class MyThread extends Thread{
@Override
public void run() {
System.out.println(“后台”);
}
}
6.4 等待线程终止join()
什么是等待线程终止join

join为线程当中的方法，某线程实例调用该方法，其他线程会等待该线程执行完毕之后在执行
package cn.itsource._08Jion;

public class TestJion {

public static void main(String[] args) throws InterruptedException {
	MyThread mt = new MyThread();
	mt.start();
	for (int i = 1; i <= 50; i++) {
		if(i ==6){
			mt.join();//到了第六次让等待一线程执行
		}
		System.out.println("二哈第:"+i+"次");
	}
}

}
class MyThread extends Thread{
@Override
public void run() {
for (int i = 1; i <= 50; i++) {
System.out.println(“一一第:”+i+“次”);
}
}
}

6.5 线程礼让
线程之前相互客气一下
static void yield() 暂停当前正在执行的线程对象，并执行其他线程。

package cn.itsource._09Yield;

public class Testyield {
/*
* 线程礼让
*
* */
public static void main(String[] args) throws InterruptedException {
MyThread mt = new MyThread();
mt.start();
for (int i = 1; i <= 50; i++) {
if(i ==6){
mt.yield();//
}
System.out.println(“啦啦啦”+i+“次”);
}
}
}
class MyThread extends Thread{
@Override
public void run() {
for (int i = 1; i <= 50; i++) {
System.out.println(“哈哈哈”+i+“次”);
}
}
}

.线程同步 [解决线程安全问题]
2.1为什么需要线程同步

解决问题：线程安全问题
（例如1单例模式的懒汉模式；例如2多线程模拟多窗口售票-）
2.2 线程同步方式一：同步代码
2.2.1基本语法结构
synchronized (同步监听对象) {
可能引发线程安全问题的代码
}
上面的结构相当于把{ }中的代码捆绑成一个整体，线程只能够一个一个的进来，执行完一个，下一个才能进来
2.2.2语法特点：
上面的同步监听对象可以是任意的对象；
保证所有的线程共享一个同步监听对象的；也就是保证被同步监听对象是被所有线程共享的。
很多时候可以写this,但是请先参照②，
常用的方式：使用类的字节码对象 XXX.class
2.2.3示例演示：
同步代码块方式①同步整块代码
结果：一个线程卖完
原因：把整个循环同步了，一旦有一个线程进来就会执行完里面的代码，其它线程才能进来
重新思考：我们需要真正的同步什么代码？保证每销售一张票的操作是同步的就可以了
同步代码块方式② 同步关键业务代码
结果：有0 -1 感觉判断失效了
原因：假设仅剩下一张票，所同步内容没有判断是否还有票，当第二线程易进入while结构体，但其他线程正在执行销售最后一张票，之后num=0;但第二线程已经进入while结构体，会执行同步代码，销售num=0的这张票
同步代码块方式③同步关键业务代码
public class TicketThread extends Thread{
private static int num = 50;
public void run() {
while(num>0){
// 只应该同步销售的一张票的操作代码
synchronized (TicketThread.class) {
// 下面的代码是销售一张票，每卖一张票的前提判断是否有票
if(num>0){
System.out.println(this.getName()+“您的票号是：”+num);
num–;
}
}
}
}
或者：将关键业务代码提出来包装成一个方法
public class TicketThread extends Thread{
private static int num = 50;
public void run() {
while(num>0){
saleOne();
}
}
// 写一个方法：销售一张票
private void saleOne(){
// 只应该同步销售的一张票的操作代码
synchronized (TicketThread.class) {
// 下面的代码是销售一张票，每卖一张票的前提判断是否有票
if(num>0){
System.out.println(this.getName()+" 您的票号是："+num);
num–;
}
}
}
}
2.3 线程同步方式二：同步方法
1、就是在需要被同步的方法上面加关键字 synchronized
2、加的位置：在返回值类型的前面
3、不需要也不能够显示的写同步监听对象
4、如果是一个非static的方法，那么同步监听对象就是this;
5、如果是static修饰的方法，那么同步监听对象就是当前方法所在的类的字节码对象
6、售票示例同步方法代码清单：
public class TicketThread implements Runnable{
private int num = 50;
public void run() {
while(num>0){
saleOne();
}
}
synchronized private void saleOne(){
if(num>0){
System.out.println(" 您的票号是："+num);
num–;
}
}
}
2.4 线程同步方式三：锁机制
1、学习方式（查找API文档方式）锁-- Lock(API)接口 —XXX实现类

2、结果：没有同步到
3、原因：lock是一个实例变量，因此创建了3个TicketThread对象就有3个lock对象，没有同步到
4、解决办法： static lock ; 或者使用实现的方式
3.线程通信与等待唤醒
3.1 什么是线程通信

感觉是多个线程之间会发生一些关系，会交流…例如：
3.2 经典案例
案例说明：

使用多个线程模拟同时操作一个银行账户;
使用一个线程模拟取款操作;使用要给线程模拟存款操作 ;要求：存款操作循环十二次;取款操作循环十二次;存取款线程同时启动;看到效果存一次，取一次交替

备注：存取交替也就是两个线程交替执行
3.3 如何实现
问题:感觉两个线程，主体中有一个循环，都会执行十二次，当把两个线程启动起来，执行感觉是由CPU来控制的
需要设计一些什么类
一个存款线程类
一个取款线程类
银行账户类
测试类
如何让两个线程交替执行
如果当前线程是存款线程,判断银行账户中是否有钱，如果有钱，让当前线程等待，唤醒取款线程
如果当前线程是取款线程，判断银行账户中是有钱，如果没有前，让当前线程等待，唤醒存款线程

如何判断？

在银行账户类当中设置一个标识，boolean empty = true;当empty为ture表示银行没有钱
①存款线程判断如果为empty为ture,表示没有钱，则执行线程存款操作，存款结束之后，
设置当前正在执行的存款线程等待
修改标识empty=flase表示银行有钱了
唤醒取款线程
②取款线程判断如果为empty为false,表示有钱，则执行线程取款操作，取款结束之后，
设置当前正在执行的取款线程等待
修改标识empty=true表示银行有钱了
唤醒存款线程
如何让线程等待或者唤醒
Object 其中有两个方法

wait():如果一个线程调用了该方法，没有唤醒该线程它，它就一直等待
notify():唤醒共享该对象的单个线程，可能是任意的一个。
3.4实现示例
方式①同步方法
public class Account {
//成员字段表示账户金池
private double blance;
//定义一个字段默认是是没有钱的
private static boolean empty = true;//empty为true表示没有钱！
//成员字段提供getter,setter方法
public double getBlance() {
return blance;
}
public void setBlance(double blance) {
this.blance = blance;
}
//提供有参构造方法初始化字段
Account(double blance){
this.blance = blance;
}
//提供存取款的动作
synchronized void save(){//synchronized同步静态方法，同步的对象是this；静态同步的是当前类的Class对象
if(!this.empty){
try {
this.wait();
} catch (InterruptedException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}
System.out.println(“存款前金额：”+blance);
this.blance += 1000;
System.out.println(“存款后金额：”+blance);
this.empty = false;
this.notify();

}
synchronized public void get(){
if(this.empty){
try {
this.wait();
} catch (InterruptedException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}
System.out.println(“取款前金额：”+blance);
this.blance -= 1000;
System.out.println(“取款后金额：”+blance);
this.empty = true;
this.notify();
}
}
方式②同步代码块
public class Account {
//成员字段表示账户金池
private double blance;
//定义一个字段默认是是没有钱的
private static boolean empty = true;//empty为true表示没有钱！
//创建一个对象用来当做同步监听对象
Object o = new Object();
//成员字段提供getter,setter方法
public double getBlance() {
return blance;
}
public void setBlance(double blance) {
this.blance = blance;
}
//提供有参构造方法初始化字段
Account(double blance){
this.blance = blance;
}
//提供存取款的动作
public void save(){//synchronized同步静态方法，同步的对象是this；静态同步的是当前类的Class对象
synchronized (o){//mutex同步监听对象
if(!empty){
try {
o.wait();
} catch (InterruptedException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}
System.out.println(“存款前金额：”+blance);
this.blance += 1000;
System.out.println(“存款后金额：”+blance);
this.empty = false;
o.notify();
}
}
public void get(){
synchronized (o){
if(empty){
try {
o.wait();
} catch (InterruptedException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}
System.out.println(“取款前金额：”+blance);
this.blance -= 1000;
System.out.println(“取款后金额：”+blance);
this.empty = true;
o.notify();
}
}
}

方式③锁机制
public class Account {
//成员字段表示账户金池
private double blance;
//定义一个字段默认是是没有钱的
private static boolean empty = true;//empty为true表示没有钱！
//定义一把锁
private final static ReentrantLock lock = new ReentrantLock();
//Condition实例用于获取被监听实例
final Condition condition = lock.newCondition();
//成员字段提供getter,setter方法
public double getBlance() {
return blance;
}
public void setBlance(double blance) {
this.blance = blance;
}
//提供有参构造方法初始化字段
Account(double blance){
this.blance = blance;
}
//提供存取款的动作
public void save(){
lock.lock();
try{
if(!this.empty){
try {
condition.await();
} catch (InterruptedException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}
System.out.println(“存款前金额：”+blance);
this.blance += 1000;
System.out.println(“存款后金额：”+blance);
this.empty = false;
condition.signal();
}finally{
lock.unlock();
}
}
public void get(){
lock.lock();
try{
if(this.empty){
try {
condition.await();
} catch (InterruptedException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}
System.out.println(“取款前金额：”+blance);
this.blance -= 1000;
System.out.println(“取款后金额：”+blance);
this.empty = true;
condition.signal();
}finally{
lock.unlock();
}
}
}
4.线程的生命周期
1、简单来说就是从什么时候开始，到什么时候结束
2、线程的声明周期分几个阶段：
① 线程 ; 类女朋友
① 创建 ; 例如 Thread t = new Thread(); 女朋友
② 就绪 ; 调用了start方法 t.start() —> 告诉CPU我准备好了女朋友准备好了
③ 运行 ; 获得CPU的资源，开始执行线程体中的代码
④ 死亡 ; 有多种情况导致死亡，

例如线程体执行完毕（自然老死）；漏气…
非自然死亡（异常没有处理好）;
对象失去引用被人偷了
对象被垃圾回收机制销毁丢弃
3、注意点：
① 休眠等操作可能导致正在运行的线程阻塞]，阻塞完了（sleep完了）进入的是就绪状态
相互一一直等待,出现死锁!
② 一个线程死了就死了，不能够死而复生

Ricardo_M_Zhou

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
线程(同步)

什么是线程任务管理器可以有多个进程，每个进程运行的都是可执行程序，一个可执行程序就是一个软件，可执行程序的本质就是在计算机当中运行的一块代码进程：可以看成是在计算机当中运行的一块代码线程：可以看成是在计算机当中运行的一小块代码2.3线程与进程的关系一个进程中可以有多个线程，至少得有一个线程；上面说一个进程可以狭隘的看成是一大段代码，那其实线程也是一段代码线程是进程中的最小单位；...
复制链接

扫一扫