Java第十一天笔记01——多线程编程

最新推荐文章于 2024-10-17 10:27:13 发布
最新推荐文章于 2024-10-17 10:27:13 发布
阅读量456 收藏 1
点赞数
文章标签： java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_43861647/article/details/122526637
版权

目录

1.进程和线程的区别

2.多线程的实现

3.多线程状态及生命周期

4.线程中的主要方法

5.线程的优先级

6.线程的高级操作

7.线程同步

8.死锁

9.Lock对象

1.进程和线程的区别

  • 每个进程都有独立的代码和数据空间，进程的切换会有很大的开销
  • 同一类线程共享代码和数据空间，每个线程有独立运行的栈和程序计数器，线程切换的开销小
     

2.多线程的实现

(1)  创建线程类
继承Thread类或实现Runnable接口
(2)  通过Thread类构造器来创建线程对象
Thread( )
Thread(Runnable target)
(3)  通过start()方法激活线程对象

例子：

（1）创建继承Thread的类

package test;

public class ThreadTest extends Thread{//基层Thread类

	@Override
	public void run() {
		for (int i = 0; i < 200; i++) {
			System.out.println(Thread.currentThread().getName() + ":" + i + " ");
		}
	}

}

（2）创建实现Runnable接口的类

package test;

public class RunnableTest implements Runnable{//实现Runnable接口

	@Override
	public void run() {
		for (int i = 0; i < 200; i++) {
			System.out.println(Thread.currentThread().getName() + ":" + i + " ");
		}
	}

}

（3）测试

package test;

public class Test {
	public static void main(String[] args) {
		ThreadTest test1 = new ThreadTest();
		test1.start();//使线程就进入就绪状态
		test1.setName("test1");//设置test1线程的名字
		
		RunnableTest runnable = new RunnableTest();
		Thread test2 = new Thread(runnable);
		test2.setName("test2");//设置test2线程的名字
		test2.start();
	}
}

3.多线程状态及生命周期

4.线程中的主要方法

 例子：

ThreadTest类：

package test;

public class ThreadTest extends Thread{//基层Thread类

	@Override
	public void run() {
		for (int i = 0; i < 200; i++) {
			System.out.println(Thread.currentThread().getName() + ":" + i + " ");
		}
	}

}

RunnableTest类：

package test;

public class RunnableTest implements Runnable{//实现Runnable接口

	@Override
	public void run() {
		for (int i = 0; i < 200; i++) {
			System.out.println(Thread.currentThread().getName() + ":" + i + " ");
		}
	}

}

Test类：

package test;

public class Test {
	public static void main(String[] args) {
		ThreadTest test1 = new ThreadTest();
		test1.start();//使线程就进入就绪状态
		test1.setName("test1");
		try {
			test1.join();//等待test1线程执行完毕，再执行其它线程
		} catch (InterruptedException e) {
			e.printStackTrace();
		}
		
		RunnableTest runnable = new RunnableTest();
		Thread test2 = new Thread(runnable);
		test2.setName("test2");
		test2.start();
		
		Thread.yield();//让出CPU，当前线程进入就绪队列等待调度
		
		RunnableTest runnable2 = new RunnableTest();
		Thread test3 = new Thread(runnable2);
		test3.setName("test3");
		test3.start();
		try {
			Thread.sleep(50);//将当前线程睡眠50毫秒
		} catch (InterruptedException e) {
			e.printStackTrace();
		}
	}
}

5.线程的优先级

  • Java提供一个线程调度器来监控程序中启动后进入就绪状态的所有线程，线程调度器按照线程的优先级来决定应调度哪个线程来执行
  • Java线程的优先级用1～10的整数来表示，越小则优先级越低
  • 但是Java的优先级是高度依赖于操作系统的实现的
     

 Thread类的三个常量，表示常用的线程优先级：

  • Thread.MIN_PRIORITY ：1
  • Thread.NORM_PRIORITY：5
  • Thread.MAX_PRIORITY：10

缺省时线程具有NORM_PRIORITY，通过getPriority()和setPriority()获取和设置线程优先级

package test;

public class Test {
	public static void main(String[] args) {
		ThreadTest test1 = new ThreadTest();
		test1.start();//使线程就进入就绪状态
		test1.setName("test1");
		System.out.println(test1.getPriority());//5，test1线程优先级
		test1.setPriority(Thread.MIN_PRIORITY);//设置test2线程优先级为1
		
		RunnableTest runnable = new RunnableTest();
		Thread test2 = new Thread(runnable);
		test2.setName("test2");
		test2.setPriority(Thread.MAX_PRIORITY);//设置test2线程优先级为10
		test2.start();
		
		RunnableTest runnable2 = new RunnableTest();
		Thread test3 = new Thread(runnable2);
		test3.setName("test3");
		test3.start();
		test1.setPriority(Thread.NORM_PRIORITY);//设置test3线程优先级为5
	}
}

6.线程的高级操作

Object类中线程的相关方法：
①void wait() 
导致当前的线程等待，直到其他线程调用此对象的 notify()方法或 notifyAll() 方法。
②void notify() 
唤醒在此对象监视器上等待的单个线程。
③void notifyAll() 
唤醒在此对象监视器上等待的所有线程。

例子：

 ①Bread类

package com.waitandnotify.test;

/**
 * 面包程序： 1.如果有面包那么就销售面包 2.如果没有面包那么就生产面包
 * 
 * 
 * 如果希望实现线程之间互相通知的效果： 1.线程调用的方法必须能够锁定对象的状态，可以是锁定方法，也可以是直接锁定对象 2. 有线程调用wait方法
 * 让出cpu的时间片 3.有线程调用notifyAll方法，唤醒其他等待对象所得线程 4.2和3在不同的代码块中（ 线程中）调用
 */
public class Bread {

	private Boolean isHave = false;// 默认没有面包

	// 销售面包的方法
	public synchronized void sale() {
		if (isHave) {
			System.out.println(Thread.currentThread().getName() + "销售面包的方法sale()");
			// 销售完面包没了
			isHave = false;
			this.notifyAll();// 虽然唤醒所有等着面包对象的锁的人，实际真正抢到时间片的线程只有一个
		} else {
			// 销售面包的人，没有面包销售时就等着，等生产者生产面包之后通知他
			try {
				System.out.println(Thread.currentThread().getName() + "在等待对象的锁");
				this.wait();
			} catch (InterruptedException e) {
				e.printStackTrace();
			}
			System.out.println(Thread.currentThread().getName() + "有面包了，完成sale方法");
		}
	}

	// 生产面包的方法
	public synchronized void produce() {
		// p1 p2
		if (!isHave) {
			// p1 p2
			System.out.println(Thread.currentThread().getName() + "生产面包的方法");
			// 销售完面包没了
			isHave = true;
			this.notifyAll();// 虽然唤醒所有等着面包对象的锁的人，实际真正抢到时间片的线程只有一个
		} else {
			// 生产面包的人，没有面包销售时就等着，等着销售面包之后通知他
			try {
				System.out.println(Thread.currentThread().getName() + "在等待对象的锁");
				this.wait();
			} catch (InterruptedException e) {
				e.printStackTrace();
			}
			System.out.println(Thread.currentThread().getName() + "没有面包了，完成produce方法");
		}
	}
}

②ProductThread类

package com.waitandnotify.test;

public class ProductThread implements Runnable {

	private Bread bread;

	public ProductThread(Bread bread) {
		this.bread = bread;
	}

	@Override
	public void run() {
		for (int i = 0; i < 200; i++) {
			bread.produce();
		}
	}

}

③SaleThread类

package com.waitandnotify.test;

public class SaleThread implements Runnable{

	private Bread bread = null;
	
	public SaleThread(Bread bread) {
		this.bread = bread;
	}
	
	@Override
	public void run() {
		for (int i = 0; i < 200; i++) {
			bread.sale();
		}
	}
}

④Test测试类

package com.waitandnotify.test;

public class Test {
	public static void main(String[] args) {
		Bread bread = new Bread();
		SaleThread sale1 = new SaleThread(bread);
		ProductThread prod1 = new ProductThread(bread);
		
		Thread s1 = new Thread(sale1);
		s1.setName("销售者1");
		
		Thread p1 = new Thread(prod1);
		p1.setName("生产者1");
		s1.start();
		p1.start();
	}
}

 7.线程同步

  • 有时两个或多个线程可能会试图同时访问一个资源
  • 为了确保在任何时间点一个共享的资源只被一个线程使用，使用了synchronized关键字实现“同步” 
  • 当一个线程运行到需要同步的语句后，CPU不去执行其他线程中的、可能影响当前线程中的下一句代码的执行结果的代码块，必须等到下一句执行完后才能去执行其他线程中的相关代码块，这就是线程同步

 （1）实现线程同步的两种方式

①synchronized方法

synchronized void methodA() {  }

②synchronized语句

synchronized (Object) {
    //要同步的语句
}

（2）注意事项

 受到synchronized保护的程序代码块和方法中，要访问的对象属性必须设定为private，因为如果不设定为private，那么就可以用不同的方式来访问它，这样就达不到保护的效果了

（3）例子

Ticket类

package com.ticket.test;

public class Ticket implements Runnable {
	private int number = 100;// 一共100张票

	public synchronized void purchase() {// 购票
		if (number > 0) {
			System.out.println(Thread.currentThread().getName() + "买了票：No." + number);
			number--;
		}
	}

	@Override
	public void run() {
		for (int i = 0; i < 10; i++) {
			purchase();
		}
	}

	public static void main(String[] args) {
		Ticket ticket = new Ticket();
		Thread t1 = new Thread(ticket);
		t1.setName("小明");
		Thread t2 = new Thread(ticket);
		t2.setName("小红");
		Thread t3 = new Thread(ticket);
		t3.setName("小刚");
        //三个人同时抢票
		t1.start();
		t2.start();
		t3.start();
	}
}

8.死锁

 （1）概念

两个线程，彼此在等待对方占据的锁

（2）锁归还的几种方式

  • 基本上执行完同步的程序代码后，锁就会自动归还；
  • 用break语句跳出同步的语句块，不过这对于写在方法声明的synchronized没有作用；
  • 遇到return语句；
  • 遇到了异常；

（3）例子

 Thread1类

package com.dielock.test;

public class Thread1 extends Thread{
	Object o1 = null;
	Object o2 = null;
	
	public Thread1(Object o1, Object o2){
		this.o1 = o1;
		this.o2 = o2;
	}

	@Override
	public void run() {
		synchronized (o1) {
			try {
				Thread.sleep(500);
				synchronized (o2) {
					System.out.println("o2");
				}
			} catch (InterruptedException e) {
				e.printStackTrace();
			}
		}
	}
}

Thread2类：

package com.dielock.test;

public class Thread2 extends Thread{

	Object o1 = null;
	Object o2 = null;
	
	public Thread2(Object o1, Object o2){
		this.o1 = o1;
		this.o2 = o2;
	}
	
	@Override
	public void run() {
		synchronized(o2){
			try {
				Thread.sleep(500);
				synchronized(o1){
					System.out.println(o1);
				}
			} catch (InterruptedException e) {
				e.printStackTrace();
			}
		}
	}
}

Test测试类：

package com.dielock.test;

public class Test {
	
	public static void main(String[] args) {
		Object o1 = new Object();
		Object o2 = new Object();
		Thread1 t1 = new Thread1(o1, o2);
		t1.setName("t1");
		t1.start();
		Thread2 t2 = new Thread2(o1, o2);
		t2.setName("t2");
		t2.start();
	}
}

9.Lock对象

如何锁对象？

  • 不要锁方法
  • 把进入面包房要执行的工作代码放入锁对象的代码块中
  • 注意事项：如果访问对象的属性，那么属性必须是私有的
package com.ticket.test;

import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;

public class Ticket implements Runnable {
	private int num = 100;// 一共一百张票
	private Lock lock = new ReentrantLock();//创建锁对象

	@Override
	public void run() {
		lock.lock();//上锁
		for (int i = 0; i < 10; i++) {//一人买十张
			if (num > 0) {
				System.out.println(Thread.currentThread().getName() + "买了No." + num);
				num--;
			} else {
				break;
			}
		}
		lock.unlock();//解锁
	}

	public static void main(String[] args) {
		Ticket ticket = new Ticket();
		Thread t1 = new Thread(ticket);
		Thread t2 = new Thread(ticket);
		Thread t3 = new Thread(ticket);
		t1.setName("XiaoHong");
		t2.setName("XiaoLiu");
		t3.setName("XiaoXin");
		t1.start();
		t2.start();
		t3.start();
	}
}

输出结果：

XiaoHong买了No.100
XiaoHong买了No.99
XiaoHong买了No.98
XiaoHong买了No.97
XiaoHong买了No.96
XiaoHong买了No.95
XiaoHong买了No.94
XiaoHong买了No.93
XiaoHong买了No.92
XiaoHong买了No.91
XiaoLiu买了No.90
XiaoLiu买了No.89
XiaoLiu买了No.88
XiaoLiu买了No.87
XiaoLiu买了No.86
XiaoLiu买了No.85
XiaoLiu买了No.84
XiaoLiu买了No.83
XiaoLiu买了No.82
XiaoLiu买了No.81
XiaoXin买了No.80
XiaoXin买了No.79
XiaoXin买了No.78
XiaoXin买了No.77
XiaoXin买了No.76
XiaoXin买了No.75
XiaoXin买了No.74
XiaoXin买了No.73
XiaoXin买了No.72
XiaoXin买了No.71

·青红造了个白·
关注
Java多线程编程核心技术第三章笔记
sunxm1992的博客
01-23 491
1.wait()方法：将当前正在执行的线程置入“预处理队列”中，并且在wait（）代码处停止执行。需要注意的是在调用wait（）方法的时候必须获得该对象的对象级别锁，即wait（）方法必须放在同步代码块中。否则在运行的时候会抛出IllegalMonitorStateException，它是RuntimeException的一个子类，所以无需try-catch进行捕捉异常。 2.notify（）也需
《Java核心技术》学习笔记——第12章 并发
a602389093的博客
12-23 503
版权声明：本文为博主ExcelMann的原创文章，未经博主允许不得转载。 第12章 并发 作者：ExcelMann，转载需注明。 第12章内容目录： 什么是线程 线程属性 线程安全的集合 异步计算 线程状态 同步 任务和线程池 进程 ...
编写线程类:继承Thread 类
yiXin_Chen的博客
09-21 733
package com.one.thread; /** * 线程类, 使用Thread * @author Administrator * */ public class MyThread extends Thread { public MyThread() { } public MyThread(String name) { super(name); } @Override public void run(){ for (int i = 1; i <=.
Java学习基础笔记——多线程基础部分
jiangnank的博客
06-18 949
Java多线程基础知识
java笔记——多线程笔记
theone_ID的博客
11-09 607
Java学习笔记
狂神说Java学习笔记——多线程
weixin_65098078的博客
07-19 1553
狂神说Java学习笔记——多线程
【2022最新Java面试宝典】—— 多线程面试（60道含答案）
记录各种Bug解决案例及日常学习内容
05-06 7470
目录1. 多线程有什么用？2. 线程和进程的区别是什么？3. Java 实现线程有哪几种方式？4. 启动线程方法 start()和 run()有什么区别？5. 怎么终止一个线程？如何优雅地终止线程？6. 一个线程的生命周期有哪几种状态？它们之间如何流转的？7. 线程中的 wait()和 sleep()方法有什么区别？8. 多线程同步有哪几种方法？9. 什么是死锁？如何避免死锁？10. 多线程之间如何进行通信？11. 线程怎样拿到返回结果？12. violatile 关键字的作用？13. 新建 T1、T2、T
Java多线程编程详解——快速上手附代码
weixin_48610702的博客
09-16 814
Java多线程编程详解——快速上手附代码 Java多线程编程方面涉及到的知识，结合B站狂神说视频总结笔记，附代码。 文章目录Java多线程编程详解——快速上手附代码一、创建多线程的方法二、静态代理三、Lambda表达式四、线程状态五、 常用线程方法1. 线程停止2. 线程休眠——sleep()3. 线程礼让——yield()4. 线程强制执行——join()5. 线程状态观测——Thread.State六、线程优先级七、守护线程八、线程同步1. synchronized关键字2. CopyOnWriteA
《Java面向对象程序设计》学习笔记——第 15 章 Java 多线程机制
weixin_45940369的博客
09-10 2415
第 15 章 Java 多线程机制 Java 语言的一大特点就是内置了对多线程的支持。多线程是指同时存在几个执行体，按几条不同的执行线索共同工作的情况。我们感觉线程正在同步执行，但并不是真的同时执行多个线程，只是Java 快速地从一个线程切换到另一个线程。Java 虚拟机（ JVM ）负责管理线程。
Java第五天笔记01——面向对象基础
lqh的博客
01-07 531
1.面向过程和面向对象的编程思想 （1）面向过程解决问题的思路： 面向过程的抽象是将实现一个功能的一组命令组合成为一个函数，这个函数就能实现这一个功能，是对功能实现的一种抽象，有了函数，我们就没有必要重复写很多的代码(特殊地譬如递归，可通过循环替代)，仅仅一个代码集合名称以及参数就能调用抽象的命令集合。 （2）面向对象解决问题的思路： 从现实世界中客观存在的事物出发来构造软件系统，并在系统构造中尽可能运用人类的自然思维方式，强调直接以问题域中的事物为中心来思考问题，认识问题，并根据这些事物的本质特..
《Java 多线程编程核心技术》笔记——第3章 线程间通信（二）
bm1998
12-13 189
文章目录3.1 等待/通知机制3.1.11 生产者/消费者模式实现3.1.11.1 一生产与一消费：操作值3.1.11.2 多生产与多消费：操作值——假死3.1.11.3 多生产与多消费：操作值3.1.11.4 一生产与一消费：操作栈3.1.11.5 一生成与多消费——操作栈：解决 wait 条件改变和假死3.1.11.6 多生产与一消费3.1.11.7 多生产与多消费：操作栈3.1.12 通过管道进行线程间通信：字节流3.1.13 通过管道进行线程间通信：字符流3.1.14 实战：等待/通知之交换备份
java编程思想学习笔记——21多线程
Burnup_110的博客
04-01 544
一、并发简介 实现并发最直接的方式是在操作系统级别使用进程。进程是运行在它自己的地址空间内的自包含的程序。多任务操作系统可以通过周期性地将CPU 从一个进程切换到另一个进程，来实现同时运行多个进程（程序）。对于进程来说，他们之间没有任何彼此通信的需要，因为他们都是完全独立的。 但是如果将进程当做并发的唯一选择，那么进程来做并发来说的话，也有他的局限性，因为进程通常来说是有数量和开销的限制的，以避免他们在不同的并发系统之间的可应用性 java采用在顺序型语言的基础上提供对线程的支持，即线程机制是在由执行程序表
Java基础笔记06——面向对象编程篇
qq_43689353的博客
05-04 895
面向对象编程
【C++刷题】力扣-#121-买卖股票的最佳时机
会写代码的饭桶
10-16 550
给定一个数组 prices，其中 prices[i] 表示第 i 天的股票价格。假设你可以在第 i 天买入并在第 j 天卖出股票（i ≤ j），设计一个算法来计算你所能获取的最大利润。注意你只能持有一股股票，并且你不能同时参与多笔交易（即在再次买入前必须卖出股票）。
基于SSM班级事务管理系统的设计
2401_87849773的博客
10-15 418
管理员账户功能包括：系统首页，个人中心，学生管理，班委管理，班会组织管理，健康档案管理，党员发展管理，党员培训管理，学生成绩管理。主要技术：Java,Spring,mybatis,mysql,jquery,html。班委账号功能包括：系统首页，学生管理，学生成绩管理，活动信息管理，班费通知管理。服务器：SpringBoot自带 apache tomcat。JDK版本：Java JDK1.8。数据库可视化工具： navicat。数据库版本： mysql5.7。开发系统：Windows。
Java安卓开发之Fragment开发（通俗易懂版）——第8章
一个脚本小子的博客
10-13 702
FragmentManager中的getSupportFragmentManager()方法不支持Activity，不论是旧版的FragmentManager还是新版的，因此我们要把继承Activity类改成继承AppCompatActivity类。
JavaWeb合集05-SpringBoot基础知识
最新发布
qq_57340195的博客
10-17 851
Autowrite ：自动装配，通过声明的数据类型来装配对应的bean对象。缺点，只能获取到一个相同类型的bean对象，如果有IOC容器里面有2个Bean对象，使用@Autowrite依赖注入就好报错。由于三层架构中，每一层都需要下次成来提供对应的方法，所有要new 下一次的对象，如果上一层的类名发送改变，那么上一层就需要修改对应的类名，如下。3、@Resource注解：通过它来代替@Autowrite注解，直接指定要注入的Bean对象，参数name的值就是要注入的Bean对象。
【SpringBoot的启动、处理请求整体流程（二）】
m0_50149847的博客
10-13 925
同时，如果文章有错误，也欢迎批评指正。本篇文章继之后，可以先阅读第一篇文章。
spring task的使用场景
qq_40603125的博客
10-13 374
spring任务调度框架约定的时间。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值