Java基础学习之线程

最新推荐文章于 2024-08-01 11:42:45 发布
最新推荐文章于 2024-08-01 11:42:45 发布
阅读量199 收藏 1
点赞数 1
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/lhz14/article/details/70245891
版权

一、“监视线程”通讯模型

概念：同时多个独立线程在运行，运行状态由第三方监控线程全程监控，这种模型为监视线程模型

如下所示：

二、线程同步问题

多线程程序可能存在的一个问题就是：可能会出现多个线程同时操作某一个对象的数据，结果就会出现线程对象对自己操作的数据不同步的情况。

如图：



例子：

package com.test.thread;

/**
 * 账户类
 * 
 * @author lhz
 * 
 */
public class Account {
	private int count;

	public Account(int count) {
		this.count = count;
	}

	/**
	 * 取现的方法
	 */
	public int getCount(int cash) {
		// synchronized (this) {
		if (count < cash) {
			System.out.println("你的余额不足,余额为" + count + "取现失败");
			return -1;
		}
		try {
			Thread.sleep(100);
		} catch (InterruptedException e) {
			e.printStackTrace();
		}
		count = count - cash;
		// }

		return count;

	}
}

package com.test.thread;

/**
 * 客户线程类
 * 
 * @author lhz
 * 
 */
public class Costomer extends Thread {
	private Account account;
	private int cash;
	private String type;

	public Costomer(Account account, int cash, String type) {
		this.cash = cash;
		this.account = account;
		this.type = type;
	}

	/**
	 * 取现
	 */
	public void run() {
		int result = account.getCount(cash);
		if (result < 0) {
			System.out.println(type + "取现失败，您余额不足");
		} else {
			System.out.println(type + "取现成功，您取了" + cash + "，余额还有" + result);
		}
	}
}

package com.test.thread;

public class ThreadTest {
	public static void main(String[] args) {
		Account account = new Account(5000);
		Costomer c1 = new Costomer(account, 4000, "atm");
		Costomer c2 = new Costomer(account, 3000, "柜台");
		c1.start();
		c2.start();
	}
}
会出现这里两种情况





第一张图：这个是因为，程序先执行c2.start()，调用getCount(int cash)方法，执行到休眠；c1.start()执行，执行到休眠；c2又执行，执行

count = count - cash;
此时count=2000；但是c1的count还是5000，然后c1执行 
count = count - cash;
此时count=1000，最终 count=1000.
第二张图：这个是因为，程序先执行c1.start()，调用getCount(int cash)方法，执行到休眠；c2.start()执行，执行到休眠；c1又执行，执行 

count = count - cash;
此时count=1000；但是c1的count还是5000，然后c1执行
 

count = count - cash;
此时count=2000，最终 count=2000.

不管是那种情况，对于银行来说都是亏本的，如何解决这个问题呢？

三、synchronized：同步锁关键字，锁定当前对象或者方法，一家独用

简介：

1、synchronized代码块中的语句只能有一个线程在执行      

2、任意一个对象都有一个标志位，有1和0两种状态
3、当程序执行到synchronized代码块的时候线程会检查对象的标志位是1还是0

4、如果是1则执行程序，同是将对象的标志位设置为0，其他线程执行到synchronized代码块时一看对象标志位为0 则线程会阻塞，一直等到对象的标志位为1再执行下面的程序 

实例（还是上面的例子）：锁定同一个对象

synchronized (this) {
			if (count < cash) {
				System.out.println("你的余额不足,余额为" + count + "取现失败");
				return -1;
			}
			try {
				Thread.sleep(100);
			} catch (InterruptedException e) {
				e.printStackTrace();
			}
			count = count - cash;
		}
四、 wait/notify机制
       在java中，每个对象都有从Object父类继承而来的两个关于线程间通讯的方法wait()和notify(),如其方法名所示，一个是等待，一个是通知，当在一个对象上调用wait()方法时，当前线程就会进行wait状态，直到收到另一个对象的notify()发出通知，才会执行下一步计算

        在多线程通讯中，经常会用对象的这两个方法，一个典型的案例就是“生产/消费者模型”

五、生产/消费者模型

模型规则
        生产和消费线程共同操作一个集合，生产线程放入对象，消费线程取出对象！仅当集合中没有对象时，生产线程会放入一个对象，如有集合中有一个对象时，消费线程要马上取出这个对象。

如图所示 ：


实例：

package com.test.thread1;

/**
 * 手机类
 * 
 * @author lhz
 * 
 */
public class Phone {
	public int type;
}


package com.test.thread1;

import java.util.ArrayList;

/**
 * 消费者
 * 
 * @author lhz
 * 
 */
public class Costomer extends Thread {
	private Phone phone;
	private ArrayList<Phone> list;

	public Costomer(Phone phone, ArrayList<Phone> list) {
		this.phone = phone;
		this.list = list;
	}

	public void run() {
		while (true) {
			// synchronized (list) {
			if (list.size() >= 1) {
				list.remove(0);// 取出
				// list.notify();
				System.out.println("消费了" + phone.type);

				phone.type++;
			} else {
				continue;
				// try {
				// list.wait();// 等待
				// } catch (InterruptedException e) {
				// e.printStackTrace();
				// }
			}
			try {
				Thread.sleep(100);
			} catch (InterruptedException e) {
				e.printStackTrace();
			}
			// }
		}
	}
}

package com.test.thread1;

import java.util.ArrayList;

/**
 * 生产者
 * 
 * @author lhz
 * 
 */
public class Product extends Thread {
	private Phone phone;
	private ArrayList<Phone> list;

	public Product(Phone phone, ArrayList<Phone> list) {
		this.phone = phone;
		this.list = list;
	}

	public void run() {
		while (true) {
			// synchronized (list) {
			if (list.size() <= 0) {
				list.add(phone);// 放入
				// list.notify();// 通知
				System.out.println("生产出" + phone.type);
				phone.type++;
			} else {
				continue;
				// try {
				// list.wait();// 等待
				// } catch (InterruptedException e) {
				// e.printStackTrace();
				// }
			}

			try {
				Thread.sleep(100);
			} catch (InterruptedException e) {
				e.printStackTrace();
			}
			// }
		}
	}
}

package com.test.thread1;

import java.util.ArrayList;

public class TestThread {
	public static void main(String[] args) {
		Phone phone = new Phone();
		ArrayList<Phone> list = new ArrayList<Phone>();
		Product p = new Product(phone, list);
		Costomer c = new Costomer(phone, list);
		p.start();
		c.start();
	}
}
cpu消耗非常大，效率低



使用了wait/notify,但是没有使用同步锁

while (true) {
			// synchronized (list) {
			if (list.size() >= 1) {
				list.remove(0);// 取出
				list.notify();
				System.out.println("消费了" + phone.type);

				phone.type++;
			} else {

				try {
					list.wait();// 等待
				} catch (InterruptedException e) {
					e.printStackTrace();
				}
			}
			try {
				Thread.sleep(100);
			} catch (InterruptedException e) {
				e.printStackTrace();
			}
			// }
		}
	
while (true) {
			// synchronized (list) {
			if (list.size() <= 0) {
				list.add(phone);// 放入
				list.notify();// 通知
				System.out.println("生产出" + phone.type);
				phone.type++;
			} else {

				try {
					list.wait();// 等待
				} catch (InterruptedException e) {
					e.printStackTrace();
				}
			}

			try {
				Thread.sleep(100);
			} catch (InterruptedException e) {
				e.printStackTrace();
			}
			// }
		}



加了同步锁

while (true) {
			synchronized (list) {
				if (list.size() <= 0) {
					list.add(phone);// 放入
					list.notify();// 通知
					System.out.println("生产出" + phone.type);
					phone.type++;
				} else {

					try {
						list.wait();// 等待
					} catch (InterruptedException e) {
						e.printStackTrace();
					}
				}

				try {
					Thread.sleep(100);
				} catch (InterruptedException e) {
					e.printStackTrace();
				}
			}
		}
while (true) {
			synchronized (list) {
				if (list.size() >= 1) {
					list.remove(0);// 取出
					list.notify();
					System.out.println("消费了" + phone.type);

					phone.type++;
				} else {

					try {
						list.wait();// 等待
					} catch (InterruptedException e) {
						e.printStackTrace();
					}
				}
				try {
					Thread.sleep(100);
				} catch (InterruptedException e) {
					e.printStackTrace();
				}
			}
		}
cpu占内存少了，不会出现做无用功情况




注意：

  1）wait和notify必须在同步锁之内使用
  2）同步锁锁定对象和wait、notify对象必须同一个
  3）当对象wait挂起状态时候是会释放同步锁的

六、线程生命周期


梁凉凉
关注
【Java基础知识 1】Java入门级概述
学Java，找哪吒
09-25 15万+
CSDN最强Java专栏，包含全部Java基础知识点、Java8新特性、Java集合、Java多线程、Java代码实例，理论结合实战，实现Java的轻松学习。
Java基础巩固之线程学习
01-20
一、线程的学习 　线程是程序中执行单个任务的顺序的流程。 　线程创建的两种方式： 　1、继承Thread类 publicstaticvoidmain(String[]args) { //继承Thread类覆盖父类run方法 Threadthread=newThread() { ...
Java多线程学习（吐血超详细总结）
热门推荐
Evankaka的专栏
03-14 42万+
本文主要讲了java中多线程的使用方法、线程同步、线程数据传递、线程状态及相应的一些线程函数用法、概述等。
Java学习路线总结，搬砖工逆袭Java架构师
学Java，找哪吒
09-07 25万+
定期分享Java硬核技术干货、分享Java学习路线、分享Java经典面试题
Java零基础之多线程篇：多线程最佳实践
喵手的博客
08-01 1286
在计算机科学领域，多线程是一种重要的编程概念。它允许程序同时执行多个任务，提高了程序的并发性和响应性。对于Java开发者而言，了解和掌握多线程编程是非常重要的一项技能。本文将从零基础开始介绍Java多线程的概念和用法，帮助读者理解多线程的原理和实践技巧。我们将深入探讨多线程的最佳实践，包括源代码解析、应用场景案例、优缺点分析和具体的Java代码测试用例。本文将带领读者逐步学习Java多线程编程的基础知识和高级概念。我们将通过详细的源代码解析和实际应用场景案例，帮助读者理解多线程的内部工作原理和使用技巧。
Java多线程（超详细！）
一只小菜鸡
05-13 13万+
1、什么是进程？什么是线程？ 进程是:一个应用程序（1个进程是一个软件）。 线程是：一个进程中的执行场景/执行单元。 注意：一个进程可以启动多个线程。 eg.对于java程序来说，当在DOS命令窗口中输入： java HelloWorld 回车之后。 会先启动JVM，而JVM就是一个进程。 JVM再启动一个主线程调用main方法。 同时再启动一个垃圾回收线程负责看护，回收垃圾。 最起码，现在的java程序中至少有两个线程并发， 一个是垃圾回收线程，一个是执行main方法的主线程。 3、进程和线程是什么关系？
Java基础知识总结（2021版）
学Java，找哪吒
01-09 25万+
前言 大家好，我是素小暖，2012年毕业，2016年通过培训转行java开发，今天2021年1月9日，转行之路跌跌绊绊，蓦然回首，已经满满的4年工作经验了？但感觉知识还是相当的匮乏，没自信，也许是努力程度还不够吧。很感谢CSDN，因为是它给了我学习的动力，之前写了一篇记录CSDN博客访问量的文章，也许大家感觉很幼稚，但真的很有用，很有效果，仿佛磕了药一样，努力学习，进步。 2020年，是我较为成功的一年，工作上，跳了槽，涨了工资；学习上，啃了几本名著（Effective Java、重构 改善既.
Java基础——多线程详解！！！！
qq_52519008的博客
10-04 4879
就是进程中的一个独立控制单元，线程在控制着进程的执行。一个进程中至少有一个进程。多线程是多任务的一种特别的形式，但多线程使用了更小的资源开销。多线程能满足程序员编写高效率的程序来达到充分利用 CPU 的目的。注意：很多多线程是模拟出来的，真正的多线程是指有多个CPU，即多核，如服务器。如果是模拟出来的多线程，即在一个CPU的情况下，在同一个时间点，CPU只执行一个代码，因为切换得很快，所以就有同时执行的错觉。程序、进程和线程的大家可以通过百度搜索得知，在这里我就不多阐述。
java基础之多线程解析
qq_50313418的博客
11-23 1191
java基础之多线程解析 下面我们通过一张图来了解一下多线程我们需要学习什么内容 程序、进程、线程 程序： 是为完成特定任务，用某种语言编写的一段代码的集合，即一段静态的代码 进程： 程序的一次执行过程或是正在运行的程序 进程作为资源分配的基本单位，系统在运行时会为每个进程分配一定的内存区域 线程： 进程可进一步细化为线程，是程序运行过程中的一条执行路径 线程作为调度和运行的最小基本单位，每个线程拥有自己独立的pc(程序计数器)和运行栈，线程切换的开销小， 可以理解为独立运行的子任
【java基础】多线程(超详细）
weixin_44571502的博客
07-13 1629
在本文中，介绍了java线程的基本知识，包括线程的创建与启动、线程的生命周期等内容
Java 并发和线程处理
沉淀、分享、成长，让自己和他人都能有所收获！
06-26 5万+
大家好，我是默语，擅长全栈开发、运维和人工智能技术。在本篇博客中，我们将深入探讨 Java 并发和线程处理的最佳实践，特别是在多线程编程中如何确保线程安全性和避免死锁。理解并发编程的原理及应用场景，对于开发高效稳定的 Java 应用程序至关重要。通过这篇文章，您将全面掌握 Java 并发处理的核心技术，并学会如何在实际项目中有效应用这些技术。并发是指多个任务在同一时间段内执行，线程是操作系统能够独立执行调度的最小单位。在 Java 中，通过多线程编程可以实现并发任务的处理，提高程序的执行效率。
Java基础 学习笔记 Markdownr版
06-27
本学习笔记主要涵盖了Java的基础知识，包括面向对象、集合、IO流、多线程、反射与动态代理以及Java 8的新特性等方面，旨在帮助初学者或有经验的开发者巩固和提升Java编程技能。 1. 面向对象（OOP）：Java的核心是...
java学习资料-线程
06-16
Java中的线程是并发编程的基础，它允许程序同时执行多个任务。在Java中，线程的创建和管理是通过多种方式实现的，包括继承Thread类、实现Runnable接口以及实现Callable接口。 1. 继承Thread类 当你创建一个新的...
JAVA零基础到高级进阶特训营 JAVA多线程并发设计+Spring高级+数据库开发+JAVA基础等
08-04
这套课程既可以作为从零基础开始学习的JAVA基础到高级学习教程，对于有JAVA基础的同学来说可以略过前面的JAVA基础章节，直接学习后续的JAVA高级部分课程。更可以灵活的作为章节技术，进行针对性的JAVA学习。还是要...
Java-学习多线程总结上
12-22
所以在进程之上的进一步划分就变得非常的重要，而且性能也会有所提高，所有的线程一定要依附进程才能够存在，那么进程一旦消失，线程也一定会消失，但反过来不一定，而Java是支持多线程的开发语言之一。 2. 多线程的...
VB程序实例-图像的打印.zip
11-03
VB程序实例-图像的打印.zip
VB程序实例-字形窗口.zip
最新发布
11-03
VB程序实例-字形窗口.zip
VB程序实例36_动态控制_增减控件.zip
11-03
VB程序实例，可供参考学习使用，希望对你有所帮助
技术资料分享CC2530非常好的技术资料.zip
11-03
技术资料分享CC2530非常好的技术资料.zip
Java零基础自学：线程详解
"Java线程基础教程，涵盖了线程的概念、生命周期、实现方式、优先级、同步和线程组等内容，适合Java初学者学习。" 在计算机编程中，特别是Java语言，线程是一个非常重要的概念，它允许程序在同一时间执行多个独立的...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值