首页 / JAVA / Java基础(八)线程
Java基础(八)线程
内容导读
互联网集市收集整理的这篇技术教程文章主要介绍了Java基础(八)线程,小编现在分享给大家,供广大互联网技能从业者学习和参考。文章包含16205字,纯文字阅读大概需要24分钟。
内容图文
![Java基础(八)线程](/upload/InfoBanner/zyjiaocheng/647/a036e0f26ede409daa0be8e3aafced7f.jpg)
电脑cpu cpu核数
几核的cpu,就代表同一瞬间能处理的任务数。
主频:cpu在进程之间频繁切换
10核CPU 主频100MHZ
1核 CPU 主频3GHZ
核数差别不大,主频高好些,核数差别不大,核数多好些
目录
一、基本概念:程序 - 进程 - 线程
程序(program)是为完成特定任务、用某种语言编写的一组指令的集合。即指一段静态的代码,静态对象。
进程(process)是程序的一次执行过程,或是正在运行的一个程序。动态过程:有它自身的产生、存在和消亡的过程。
?如:运行中的QQ,运行中的MP3播放器 ?程序是静态的,进程是动态的线程(thread),进程可进一步细化为线程,是一个程序内部的一条执行路径。
?若一个程序可同一时间执行多个线程,就是支持多线程的 ?进程相当于一条河,线程就相当于河流的分支;
何时需要多线程
程序需要同时执行两个或多个任务。
程序需要实现一些需要等待的任务时,如用户输入、文件读写操作、网络操作、搜索等。
需要一些后台运行的程序时。
多线程的创建和启动--异步
二、实现多线程
继承Thread的方式实现多线程
/**
* 继承Thread的方式实现多线程
*/
public class TestThread extends Thread{
@Override
public void run() {
System.out.println("多线程运行的代码");
for(int i = 0; i < 5; i++){
System.out.println("这是多线程的逻辑代码:" + i);
}
}
}
通过实现Runnable接口方式实现多线程
/**
* 通过实现Runnable接口方式实现多线程
*/
public class TestRunnable implements Runnable{
//多个线程可以共享同一个接口实现类的对象,非常适合多个相同线程来处理同一份资源(count)
int count = 0;
@Override
public void run() {
System.out.println(Thread.currentThread().getName() + ":Runnable多线程运行的代码");
for(int i = 0; i < 5; i++){
count++;
System.out.println(Thread.currentThread().getName() + ":这是Runnable多线程的逻辑代码:" + count);
}
}
}
测试:
public class Test {
public static void main(String[] args) {
// Thread t0 = new TestThread();//继承Thread类的线程
// t0.start();//启动线程,开始运行run方法中的代码
//
// Thread t1 = new TestThread();
// t1.start();
// Thread t2 = new TestThread();
// t2.start();
// Thread t3 = new Thread(new TestRunnable());
// t3.start();
// Thread t4 = new Thread(new TestRunnable(), "t-1");
// t4.start();
// Thread t5 = new Thread(new TestRunnable(), "t-2");
// t5.start();
Runnable run = new TestRunnable();
Thread t4 = new Thread(run, "t-1");
t4.start();
Thread t5 = new Thread(run, "t-2");
t5.start();
// new Test().test();
System.out.println("---------------1");
System.out.println("---------------2");
System.out.println("---------------3");
/**
* 多次运行这个main方法之后
* 我们发现main方法中打印的3行与开启线程运行run方法中的打印语句是混合起来
* 而且main方法中的打印与run方法中打印语句顺序是不固定的
* 为什么呢?
* main执行t0.start()方法开启多线程之后,就相当于在main方法之外开启一个支流
* 这个个时候t0.start()的之后的main方法的其他代码的运行就与run方法运行无关了
* 以当前代码为例
* t0.start()的之后的main方法的其他代码与run方法的代码并行运行
* 就像两条河流一样,各走各的
* 那么控制台输出的结果就是两条并行程序的运行结果总和,这个结果需要拆开成两部分看
* 就可以看到,各自是保持自己输出顺序
* 这个就是多线程的异步,这个异步相对于执行t0.start()的主程序来说的
* 简单来说开启了线程之后run方法中运行的代码主程序中t0.start()之后的程序是并行执行的,没先后关系,这个叫异步
*/
}
public void test(){
System.out.println("多线程运行的代码");
for(int i = 0; i < 5; i++){
System.out.println("这是多线程的逻辑代码:" + i);
}
}
}
继承方式和实现方式的联系与区别
public class Thread extends Object implements Runnable
【区别】
继承Thread: 线程代码存放Thread子类run方法中。重写run方法
实现Runnable:线程代码存在接口的子类的run方法。实现run方法
【实现接口方式的好处】
1)避免了单继承的局限性
2)多个线程可以共享同一个接口实现类的对象,非常适合多个相同线程来处理同一份资源(count)。
一般使用实现接口方式来实现多线程
使用多线程的优点
?多线程程序的优点: 1.提高应用程序的响应。对图形化界面更有意义,可增强用户体验。 2.提高计算机系统CPU的利用率 3.改善程序结构。将既长又复杂的进程分为多个线程,独立运行,利于理解和修改Thread类的有关方法
void start(): 启动线程,并执行对象的run()方法
run(): 线程在被调度时执行的操作
String getName(): 返回线程的名称
void setName(String name):设置该线程名称
static currentThread(): 返回当前线程
static void yield():线程让步
?暂停当前正在执行的线程,把执行机会让给优先级相同或更高的线程 ?若队列中没有同优先级的线程,忽略此方法join() :当某个程序执行流中调用其他线程的 join() 方法时,调用线程将被阻塞,直到 join() 方法加入的 join 线程执行完为止
?低优先级的线程也可以获得执行static void sleep(long millis):(指定时间:毫秒)
?令当前活动线程在指定时间段内放弃对CPU控制,使其他线程有机会被执行,时间到后重排队。 ?抛出InterruptedException异常stop(): 强制线程生命期结束
boolean isAlive():返回boolean,判断线程是否还活着
线程的优先级控制
?MAX_PRIORITY(10); ?MIN _PRIORITY (1); ?NORM_PRIORITY (5); u涉及的方法: ?getPriority() :返回线程优先值 ?setPriority(int newPriority) :改变线程的优先级 ?线程创建时继承父线程的优先级
public class Test1 {
public static void main(String[] args) {
TestRun run0 = new TestRun();
TestRun run1 = new TestRun();
Thread t0 = new Thread(run0);
Thread t1 = new Thread(run1);
t0.setName("线程t-0");//设置线程的名称
t1.setName("线程t-1");//设置线程的名称
// t0.setPriority(1);//设置线程的优先级
// t1.setPriority(10);//设置线程的优先级
t0.start();
t1.start();
//如果在创建线程的时候没有指定名称,系统会给出默认名称,通过getName()获取线程名称
// System.out.println(t0.getName());
// System.out.println(t1.getName());
/**
* 线程的优先级,就是哪个线程有较大个概率被执行
* 优先级是用数字1-10表示,数字越大优先级越高,如果没有设置默认优先级是5
*/
// System.out.println("t0的优先级:" + t0.getPriority());//获取线程的优先级
System.out.println("---------------1");
System.out.println("---------------2");
System.out.println(t1.isAlive());//判断当前的线程是否存活
t1.stop();//强制线程生命期结束,强制停止此线程
try {
t0.join();//相当于在这块把t0的run的代码插入到这个位置执行
/**
* 专业的说法
* 就是阻塞当前的main方法,先不执行System.out.println("---------------3");代码
* 先执行join进来的线程的代码
* join的线程执行完毕之后继续执行之前main方法阻塞的代码System.out.println("---------------3");
*/
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println("---------------3");
System.out.println(t1.isAlive());
}
}
class TestRun implements Runnable{
int count = 0;
@Override
public void run() {
System.out.println(Thread.currentThread().getName() + ":Runnable多线程运行的代码");
for(int i = 0; i < 5; i++){
// try {
// Thread.sleep(1000);//当前线程睡眠1000毫秒
// //相当于当前的这个循环每隔1000毫秒执行一次循环
// } catch (InterruptedException e) {
// e.printStackTrace();
// }
// if(i % 2 == 0){
// Thread.yield();//线程让步
// }
count++;
System.out.println(Thread.currentThread().getName() + ":这是Runnable多线程的逻辑代码:" + count);
}
}
}
三、线程的生命周期(线程从生到死整个经历)
JDK中用Thread.State枚举表示了线程的几种状态
要想实现多线程,必须在主线程中创建新的线程对象。Java语言使用Thread类及其子类的对象来表示线程,在它的一个完整的生命周期中通常要经历如下的五种状态:
?新建: 当一个Thread类或其子类的对象被声明并创建时,新生的线程对象处于新建状态 ?就绪:处于新建状态的线程被start()后,将进入线程队列等待CPU时间片,此时它已具备了运行的条件 ?运行:当就绪的线程被调度并获得处理器资源时,便进入运行状态, run()方法定义了线程的操作和功能 ?阻塞:在某种特殊情况下,被人为挂起或执行输入输出操作时,让出 CPU 并临时中止自己的执行,进入阻塞状态 ?死亡:线程完成了它的全部工作或线程被提前强制性地中止? -->stop(),断电,杀掉进程
四、线程的同步
问题的提出
?多个线程执行的不确定性引起执行结果的不稳定 ?多个线程对账本的共享,会造成操作的不完整性,会破坏数据。
多线程出现了安全问题
问题的原因:
当多条语句在操作同一个线程共享数据时,一个线程对多条语句只执行了一部分,还没有执行完,另一个线程参与进来执行。导致共享数据的错误。
解决办法:
对多条操作共享数据的语句,只能让一个线程都执行完,在执行过程中,其他线程不可以参与执行。
Java对于多线程的安全问题提供了专业的解决方式:
同步机制
1、synchronized还可以放在方法声明中,表示整个方法
为同步方法。
例如:
public synchronized void show (String name){
….
}
2、synchronized (对象){
// 需要被同步的代码;
}
在普通方法上加同步锁synchronized,锁的是整个对象,不是某一个方法
* 不同的对象就是不同的锁,普通方法加synchronized,线程使用不同的此方法的对象,还有共享资源的问题drawing1
*
* 普通方法加同步锁,锁的当前方法对应的对象,当前的对象的所有加了同步锁的方法是共用一个同步锁
静态的方法加synchronized,对于所有的对象都是使用同一个一个锁 drawing2
synchronized修饰代码块,想要根据不同的对象有不同的锁 synchronized(a),这个小括号中传入不同的对象就是不同的锁 drawing5
线程的死锁问题
死锁
?不同的线程分别占用对方需要的同步资源不放弃,都在等待对方放弃自己需要的同步资源,就形成了线程的死锁解决方法
?专门的算法、原则,比如加锁顺序一致 ?尽量减少同步资源的定义,尽量避免锁未释放的场景
package com.cn.day;
public class Test1 {
public static void main(String[] args) {
//定义账户对象
Acount a = new Acount();
Acount a1 = new Acount();
//多线程对象
User u_weixin = new User(a, 2000);
User u_zhifubao = new User(a, 2000);
Thread weixin = new Thread(u_weixin,"微信");
Thread zhifubao = new Thread(u_zhifubao,"支付宝");
weixin.start();
zhifubao.start();
}
}
class Acount{
public static int money = 3000;//全局变量,所有的操作共享这个变量
/**
* 提款,判断账户钱够不够
* 多线程调用这个方法,就有问题,线程共享资源时,一个线程在执行这个方法没有完毕时,另一个线程又开始执行这个方法
* 解决思路:显然一个线程整体执行完这个方法,另一个线程再执行
* 通过synchronized同步锁来完成
* 可以直接在方法上加上synchronized关键字
* 在普通方法上加同步锁synchronized,锁的是整个对象,不是某一个方法
* 不同的对象就是不同的锁,普通方法加synchronized,线程使用不同的此方法的对象,还有共享资源的问题
*
* 普通方法加同步锁,锁的当前方法对应的对象,当前的对象的所有加了同步锁的方法是共用一个同步锁
* @param m
*/
public synchronized void drawing(int m){
String name = Thread.currentThread().getName();
if(money < m){
System.out.println(name + "操作,账户金额不足:" + money);
}else{
System.out.println(name + "操作,账户原有金额:" + money);
System.out.println(name + "操作,取款金额:" + m);
System.out.println(name + "操作,取款操作:原金额" + money + " - " + "取款金额" + m);
money = money - m;
System.out.println(name + "操作,取款后的余额:" + money);
}
}
public synchronized void drawing1(int m){
String name = Thread.currentThread().getName();
if(money < m){
System.out.println(name + "操作,账户金额不足:" + money);
}else{
System.out.println(name + "操作,账户原有金额:" + money);
System.out.println(name + "操作,取款金额:" + m);
System.out.println(name + "操作,取款操作:原金额" + money + " - " + "取款金额" + m);
money = money - m;
System.out.println(name + "操作,取款后的余额:" + money);
}
}
/**
* 静态的方法加synchronized,对于所有的对象都是使用同一个一个锁
* @param m
*/
public static synchronized void drawing2(int m){
String name = Thread.currentThread().getName();
if(money < m){
System.out.println(name + "操作,账户金额不足:" + money);
}else{
System.out.println(name + "操作,账户原有金额:" + money);
System.out.println(name + "操作,取款金额:" + m);
System.out.println(name + "操作,取款操作:原金额" + money + " - " + "取款金额" + m);
money = money - m;
System.out.println(name + "操作,取款后的余额:" + money);
}
}
/**
* 对代码块加入同步锁
* 代码块synchronized(this),所有当前的对象的synchronized(this)同步的的代码都是使用同一个锁
* @param m
*/
public void drawing3(int m){
synchronized(this){//表示当前的对象的代码块被加了synchronized同步锁
//用this锁代码块是代表当前的对象,如果在其他方法中也有synchronized(this)的代码块使用的都是同一个同步锁
String name = Thread.currentThread().getName();
if(money < m){
System.out.println(name + "操作,账户金额不足:" + money);
}else{
System.out.println(name + "操作,账户原有金额:" + money);
System.out.println(name + "操作,取款金额:" + m);
System.out.println(name + "操作,取款操作:原金额" + money + " - " + "取款金额" + m);
money = money - m;
System.out.println(name + "操作,取款后的余额:" + money);
}
}
}
public void drawing4(int m){
synchronized(this){//表示当前的对象的代码块被加了synchronized同步锁
//用this锁代码块是代表当前的对象,如果在其他方法中也有synchronized(this)的代码块使用的都是同一个同步锁
String name = Thread.currentThread().getName();
if(money < m){
System.out.println(name + "操作,账户金额不足:" + money);
}else{
System.out.println(name + "操作,账户原有金额:" + money);
System.out.println(name + "操作,取款金额:" + m);
System.out.println(name + "操作,取款操作:原金额" + money + " - " + "取款金额" + m);
money = money - m;
System.out.println(name + "操作,取款后的余额:" + money);
}
}
}
/**
* synchronized修饰代码块,想要根据不同的对象有不同的锁
* synchronized(a),这个小括号中传入不同的对象就是不同的锁
* @param m
*/
public void drawing5(int m,Acount a){
//表示通过方法的参数传递进来的对象的代码块被加了synchronized同步锁
synchronized(a){
//不同的对象就有不同的同步锁
String name = Thread.currentThread().getName();
//如果是微信操作的,先不执行,等支付宝操作,支付宝操作完,微信再继续操作
if(name.equals("微信")){
try {
a.wait();//当前的线程进入等待的阻塞状态
} catch (InterruptedException e) {
e.printStackTrace();
}
}
if(money < m){
System.out.println(name + "操作,账户金额不足:" + money);
}else{
System.out.println(name + "操作,账户原有金额:" + money);
System.out.println(name + "操作,取款金额:" + m);
System.out.println(name + "操作,取款操作:原金额" + money + " - " + "取款金额" + m);
money = money - m;
System.out.println(name + "操作,取款后的余额:" + money);
}
if(name.equals("支付宝")){
try {
a.notify();//唤醒当前优先级最高的线程,进入就绪状态
// a.notifyAll();//唤醒当前所有的线程,进入就绪状态
} catch (Exception e) {
e.printStackTrace();
}
}
}
}
}
class User implements Runnable{
Acount acount;
int money;
public User(Acount acount,int money){
this.acount = acount;
this.money = money;
}
@Override
public void run() {
// acount.drawing(money);
// if(Thread.currentThread().getName().equals("微信")){
//// acount.drawing(money);
// acount.drawing3(money);
// }else{
//// acount.drawing1(money);
// acount.drawing4(money);
// }
// acount.drawing2(money);//调用类的静态方法
// acount.drawing3(money);
acount.drawing5(money, acount);
}
}
五、线程通信 drawing5
wait() 与 notify() 和 notifyAll()
?wait():令当前线程挂起并放弃CPU、同步资源,使别的线程可访问并修改共享资源,而当前线程排队等候再次对资源的访问 ?notify():唤醒正在排队等待同步资源的线程中优先级最高者结束等待 ?notifyAll ():唤醒正在排队等待资源的所有线程结束等待.Java.lang.Object提供的这三个方法只有在synchronized方法或synchronized代码块中才能使用,否则会报java.lang.IllegalMonitorStateException异常
经典例题:生产者/消费者问题
生产者(Productor)将产品交给店员(Clerk),而消费者(Customer)从店员处取走产品,店员一次只能持有固定数量的产品(比如:20),如果生产者试图生产更多的产品,店员会叫生产者停一下,如果店中有空位放产品了再通知生产者继续生产;如果店中没有产品了,店员会告诉消费者等一下,如果店中有产品了再通知消费者来取走产品。
这里可能出现两个问题:
生产者比消费者快时,消费者会漏掉一些数据没有取到。
消费者比生产者快时,消费者会取相同的数据。
/**
* 生产者与消费者
* @author lby
*
*/
public class Test3 {
public static void main(String[] args) {
Clerk c = new Clerk();
//消费时不生产,生产时不消费
//生产者
new Thread(new Runnable() {
@Override
public void run() {
synchronized (c) {
while(true){//无限循环代表无限的生产次数
if(c.productNum == 0){//产品数为0,开始生产
System.out.println("产品数为0,开始生产");
while(c.productNum < 4){
c.productNum++;//增加产品
System.out.println("库存:" + c.productNum);
}
System.out.println("产品数为" + c.productNum + ",结束生产");
c.notify();//唤醒消费者线程
}else{
try {
c.wait();//生产者线程等待
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
}
}
}, "生产者").start();
//消费者
new Thread(new Runnable() {
@Override
public void run() {
synchronized (c) {
while(true){//无限循环代表无限的消费次数
if(c.productNum == 4){//产品数为4,开始消费
System.out.println("产品数为4,开始消费");
while(c.productNum > 0){
c.productNum--;//消费产品
System.out.println("库存:" + c.productNum);
}
System.out.println("产品数为" + c.productNum + ",结束消费");
c.notify();//唤醒生产者线程
}else{
try {
c.wait();//消费者线程等待
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
}
}
}, "消费者").start();
}
}
class Clerk{
public static int productNum = 0;
}
?
?
流星天道酬勤
发布了25 篇原创文章 · 获赞 0 · 访问量 389
私信
关注
内容总结
以上是互联网集市为您收集整理的Java基础(八)线程全部内容,希望文章能够帮你解决Java基础(八)线程所遇到的程序开发问题。 如果觉得互联网集市技术教程内容还不错,欢迎将互联网集市网站推荐给程序员好友。
内容备注
版权声明:本文内容由互联网用户自发贡献,该文观点与技术仅代表作者本人。本站仅提供信息存储空间服务,不拥有所有权,不承担相关法律责任。如发现本站有涉嫌侵权/违法违规的内容, 请发送邮件至 gblab@vip.qq.com 举报,一经查实,本站将立刻删除。
内容手机端
扫描二维码推送至手机访问。