第八章_多线程
1.程序进程线程的概念(基本的概念:程序,进程,线程))
本节从(线程部分是从p415开始的,前面的十几集都是关于idea的使用)
本章的重点:线程的同步
有4中方式创建多线程(面试喜欢问)
jdk新增了两种
解决同步的安全问题有三种方式
2.多线程的优点
3.创建多线程的方式一(2):thread类
在上面的例子中在不考虑main方法,垃圾回收线程,异常处理线程的情况下不是多线程
一条线可以画完的不是多线程
案例
package com.hxut.java;
/**
* @author weijiangquan
* @date 2022/4/30 -16:55
* @Description
*
* 多线程的创建
* 方式一:继承于Thread类
* 1.创建一个继承于thread类的子类
* 2.重写Thread类的run() --->将此线程执行的操作声明在run中
* 3.创建Thread类的子类的对象
* 4.通过此对象调用start()
*
* 例子:遍历100以内的所有的偶数
*
*/
// 1.创建一个继承于Thread类的子类
class MyThread extends Thread{
// 2.重写Thread类的run方法
@Override
public void run() {
for (int i =0;i<100;i++){
if (i % 2 == 0) {
System.out.println(i);
}
}
}
}
public class ThreadTest{
public static void main(String[] args) {
//3.创建thread类的子类的对象
MyThread t1 = new MyThread();
//4.通过此对象调用start()
t1.start();
for(int i = 0;i<100;i++){
if(i%2==0){
System.out.println(i+"-------main-----");
}
}
}
}
4 创建过程中两个问题的说明
package com.hxut.java;
/**
* @author weijiangquan
* @date 2022/4/30 -16:55
* @Description
*
* 多线程的创建
* 方式一:继承于Thread类
* 1.创建一个继承于thread类的子类
* 2.重写Thread类的run() --->将此线程执行的操作声明在run中
* 3.创建Thread类的子类的对象
* 4.通过此对象调用start()
*
* 例子:遍历100以内的所有的偶数
*
*/
// 1.创建一个继承于Thread类的子类
class MyThread extends Thread{
// 2.重写Thread类的run方法
@Override
public void run() {
for (int i =0;i<100;i++){
if (i % 2 == 0) {
System.out.println(Thread.currentThread().getName()+":"+i);
}
}
}
}
public class ThreadTest{
public static void main(String[] args) {
//3.创建thread类的子类的对象
MyThread t1 = new MyThread();
//4.通过此对象调用start():①启动当前的线程 ②调用当前线程的run()
// t1.start();
// 问题一:我们不能直接通过调用run()的方式启动多线程
t1.run();
//如下的操作仍然是在main线程中执行的
for(int i = 0;i<100;i++){
if(i%2==0){
System.out.println(Thread.currentThread().getName()+":"+i+"-------main-----");
}
}
}
}
本节的最终的代码
package com.hxut.java;
/**
* @author weijiangquan
* @date 2022/4/30 -16:55
* @Description
*
* 多线程的创建
* 方式一:继承于Thread类
* 1.创建一个继承于thread类的子类
* 2.重写Thread类的run() --->将此线程执行的操作声明在run中
* 3.创建Thread类的子类的对象
* 4.通过此对象调用start()
*
* 例子:遍历100以内的所有的偶数
*
*/
// 1.创建一个继承于Thread类的子类
class MyThread extends Thread{
// 2.重写Thread类的run方法
@Override
public void run() {
for (int i =0;i<100;i++){
if (i % 2 == 0) {
System.out.println(Thread.currentThread().getName()+":"+i);
}
}
}
}
public class ThreadTest{
public static void main(String[] args) {
//3.创建thread类的子类的对象
MyThread t1 = new MyThread();
//4.通过此对象调用start():①启动当前的线程 ②调用当前线程的run()
t1.start();
// 问题一:我们不能直接通过调用run()的方式启动多线程
// t1.run();
//问题二:在启动一个线程,遍历100以内的偶数.不可以还让已经start()的线程去执行,
// 会报java.lang.IllegalThreadStateException异常
// t1.start();
// 我们需要重新创建一个线程耳朵对象
MyThread t2 = new MyThread();
t2.start();
//如下的操作仍然是在main线程中执行的
for(int i = 0;i<100;i++){
if(i%2==0){
System.out.println(Thread.currentThread().getName()+":"+i+"-------main-----");
}
}
}
}
5 线程方式的练习题
package com.hxut.javae1;
/**
* @author weijiangquan
* @date 2022/4/30 -17:34
* @Description 创建两个分线程,其中一个线程遍历100以内的偶数,另一个线程遍历10000以内的奇数
*
*/
public class ThreadDemo {
public static void main(String[] args) {
MyThead1 myThead1 = new MyThead1();
MyThread2 myThread2 = new MyThread2();
myThead1.start();
myThread2.start();
}
}
//线程子类1
class MyThead1 extends Thread{
@Override
public void run() {
for(int i = 0;i<=10000;i++){
if(i%2==0){
System.out.println(Thread.currentThread().getName()+":"+i);
}
}
}
}
//线程子类2
class MyThread2 extends Thread{
@Override
public void run() {
for(int i = 0;i<=10000;i++){
if(i%2!=0){
System.out.println(Thread.currentThread().getName()+":"+i);
}
}
}
}
可以看到之间有交互
也可以通过下面的方式进行创建
//创建Thread类的匿名子类的方式
new Thread(){
@Override
public void run() {
for(int i = 0;i<=10000;i++){
if(i%2==0){
System.out.println(Thread.currentThread().getName()+":"+i);
}
}
}
}.start();
new Thread(){
@Override
public void run() {
for(int i = 0;i<=10000;i++){
if(i%2!=0){
System.out.println(Thread.currentThread().getName()+":"+i);
}
}
}
}.start();
6 线程的常用方式
package com.hxut.java;
/**
* @author weijiangquan
* @date 2022/4/30 -17:50
* @Description 测试Thread中的常用方法
* 1.start():启动当前线程:调用当前线程的run()
* 2.run():通常需要重写Thread类中的此方法,将创建的线程要执行的操作声明在此方法中
* 3.currentThread():静态方法,返回当前代码的线程
* 4.getName():获得当前线程的名字
* 5.setName():设置当前线程的名字
* 6.yield():释放当前cpu的执行权(但还是有可能又抢到cpu的执行权)
* 7.join():在线程a中调用线程b的join(),此时线程b就进入阻塞状态,直到线程b完全执行完成以后,线程b才开始结束阻塞状态
* 8.stop():已经过时了.强制退出结束当前线程
* 9.sleep():让当前线程睡眠指定的毫秒数,在指定的毫秒内,当前的线程是阻塞状态
* 10.isAlive():判断当前线程是否存活
*/
class HelloThread extends Thread{
@Override
public void run() {
for(int i =0;i<100;i++){
if(i%2==0){
try {
sleep(100); //这个地方只能使用try catch,因为Thread的run()没有抛出异常(重写的时候有一条规则是,子类不能抛出比父类大的异常)
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println(Thread.currentThread().getName()+":"+i);
}
if(i%20==0){
yield();
}
}
}
}
public class ThreadMethodTest{
public static void main(String[] args) {
//************************主线程做的事***********************
HelloThread helloThread = new HelloThread();
helloThread.setName("线程1"); //
helloThread.start();
//***********************************************
//给主线程命名
Thread.currentThread().setName("主线程");
for(int i =0;i<100;i++){
if(i%2==0){
System.out.println(Thread.currentThread().getName()+":"+i);
}
if( i == 20){
try {
helloThread.join();
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
System.out.println(helloThread.isAlive());
}
}
7 线程优先级的设置(图片1)
图片(线程的优先级)
package com.hxut.java;
/**
* @author weijiangquan
* @date 2022/4/30 -17:50
* @Description 测试Thread中的常用方法
* 1.start():启动当前线程:调用当前线程的run()
* 2.run():通常需要重写Thread类中的此方法,将创建的线程要执行的操作声明在此方法中
* 3.currentThread():静态方法,返回当前代码的线程
* 4.getName():获得当前线程的名字
* 5.setName():设置当前线程的名字
* 6.yield():释放当前cpu的执行权(但还是有可能又抢到cpu的执行权)
* 7.join():在线程a中调用线程b的join(),此时线程b就进入阻塞状态,直到线程b完全执行完成以后,线程b才开始结束阻塞状态
* 8.stop():已经过时了.强制退出结束当前线程
* 9.sleep():让当前线程睡眠指定的毫秒数,在指定的毫秒内,当前的线程是阻塞状态
* 10.isAlive():判断当前线程是否存活
*
*
* 线程的优先级
* 1.
* MAX_PRIORITY:10
* MIN_PRIORITY:1
* NORM_PRIORITY:5(默认)
* 2.如何获取和设置当前线程的优先级
* getPriority();获取线程的优先级
* setPriority(int p):设置线程的优先级
* 说明:高优先级的线程要抢占低优先级线程的cpu的执行权,但只是从概率上讲,高优先级的线程高概率的情况下执行,并不意味着只有当高优先级的线程
* 执行完毕以后,低优先级的线程才执行
*/
class HelloThread extends Thread{
@Override
public void run() {
for(int i =0;i<10000;i++){
if(i%2==0){
/* try {
sleep(100); //这个地方只能使用try catch,因为Thread的run()没有抛出异常(重写的时候有一条规则是,子类不能抛出比父类大的异常)
} catch (InterruptedException e) {
e.printStackTrace();
}*/
System.out.println(Thread.currentThread().getName()+Thread.currentThread().getPriority()+":"+i);
// 也可以写成下面的这种方式 (因为它就在当前线程中)
// System.out.println(getName()+getPriority()+":"+i);
}
/* if(i%20==0){
yield();
}*/
}
}
}
public class ThreadMethodTest{
public static void main(String[] args) {
//************************主线程做的事***********************
HelloThread helloThread = new HelloThread();
helloThread.setName("分线程"); //
// 设置分分线程的优先级
helloThread.setPriority(Thread.MAX_PRIORITY); //最高
helloThread.start();
//***********************************************
//给主线程命名
Thread.currentThread().setName("主线程");
Thread.currentThread().setPriority(Thread.MIN_PRIORITY); //最低
for(int i =0;i<10000;i++){
if(i%2==0){
System.out.println(Thread.currentThread().getName()+Thread.currentThread().getPriority()+":"+i);
}
/* if( i == 20){
try {
helloThread.join();
} catch (InterruptedException e) {
e.printStackTrace();
}
}*/
}
// System.out.println(helloThread.isAlive());
}
}
8 继承Thread方式,多窗口卖票
package com.hxut.java;
/**
* @author weijiangquan
* @date 2022/4/30 -18:55
* @Description 创建三个窗口卖票:总的票数是100章
*
* 目前的这个存在线程的安全问题(后面解决)
*
*/
class Window extends Thread{
private static int ticket = 100;
@Override
public void run() {
while (true){
if(ticket>0){
System.out.println(Thread.currentThread().getName()+"卖票,票号为"+ticket);
ticket--;
}else {
break;
}
}
}
}
public class WindowTest {
public static void main(String[] args) {
Window t1 = new Window();
Window t2 = new Window();
Window t3 = new Window();
t1.setName("窗口1");
t2.setName("窗口2");
t3.setName("窗口3");
t1.start();
t2.start();
t3.start();
}
}
注意这里面的打印的顺序不一定是线程执行的顺序,打印也是需要时间的
9 创建多线程的方式二:实现Runnable接口
package com.hxut.java;
/**
* @author weijiangquan
* @date 2022/4/30 -19:53
* @Description 创建多线程的方式二:实现Runnable接口
* 1.创建一个实现了Runnable接口的类
* 2.实现类去实现Runnable中的抽象方法:run()
* 3.创建实现类的对象
* 4.将此对象作为参数传递到Thread类的构造器中,创建Thread类的对象
*4.通过Thread类的对象调用start()
*/
class MThread implements Runnable{
@Override
public void run() {
for (int i =0 ;i<100;i++){
if(i%2 == 0){
System.out.println(Thread.currentThread().getName()+":"+i);
}
}
}
}
public class ThreadTest1{
public static void main(String[] args) {
//创建实现类的对象
MThread mThread = new MThread();
// 4.将此对象作为参数传递到Thread类的构造器中,创建Thread类的对象
Thread t1 = new Thread(mThread);//看源码可以看出这里使用了多态
t1.setName("线程1");
// 4.通过Thread类的对象调用start():① 启动线程 ② 调用当前线程的run() -->调用Runnable类型的target的run
t1.start();
//再启动一个线程,遍历100以内的偶数
Thread t2 = new Thread(mThread);
t2.setName("线程2");
t2.start();
}
}
源码解析
10 实现Runable方式,多窗口卖票
package com.hxut.java;
/**
* @author weijiangquan
* @date 2022/4/30 -20:18
* @Description 创建三个窗口卖票 实现Runnable接口的方式实现卖票
* 存在线程安全问题,待解决
*/
class Window1 implements Runnable{
private int ticket = 100; //这里不用加static
@Override
public void run() {
while (true){
if(ticket>0){
System.out.println(Thread.currentThread().getName()+"卖票,票号为:"+ticket);
ticket--;
}else {
break;
}
}
}
}
public class WindowTest1 {
public static void main(String[] args) {
Window1 window1 = new Window1();
Thread t1 = new Thread(window1);
Thread t2 = new Thread(window1);
Thread t3 = new Thread(window1);
t1.setName("窗口1");
t2.setName("窗口2");
t3.setName("窗口3");
t1.start();
t2.start();
t3.start();
}
}
11 两种创建方式的对比
比较线程的两种方式
* 开发中优先考虑Runnable接口的方式
* 原因:1. 实现的方式没有类的单继承的局限性.
* 2. 实现的方式更加的适合来处理多个线程有共享数据的情况.
*
* 联系:public class Thread implements Runnable
* 相同点:两种方式都需要写run(),将线程的逻辑声明在run()中
12 线程的生命周期
图片
13 理解线程的安全问题(线程的同步)
14 多线程的安全问题的举例和解决措施
举例
package com.hxut.java;
/**
* @author weijiangquan
* @date 2022/4/30 -20:18
* @Description 创建三个窗口卖票 实现Runnable接口的方式实现卖票
* 存在线程安全问题,待解决
*/
class Window1 implements Runnable{
private int ticket = 100; //这里不用加static
@Override
public void run() {
while (true){
if(ticket>0){
try {
Thread.sleep(100);
}catch (InterruptedException e){
e.printStackTrace();
}
System.out.println(Thread.currentThread().getName()+"卖票,票号为:"+ticket);
ticket--;
}else {
break;
}
}
}
}
public class WindowTest1 {
public static void main(String[] args) {
Window1 window1 = new Window1();
Thread t1 = new Thread(window1);
Thread t2 = new Thread(window1);
Thread t3 = new Thread(window1);
t1.setName("窗口1");
t2.setName("窗口2");
t3.setName("窗口3");
t1.start();
t2.start();
t3.start();
}
}
但是我们必须要解决这个问题,不能因为概率小就不管它
问题分析
package com.hxut.java;
/**
* @author weijiangquan
* @date 2022/4/30 -20:18
* @Description 创建三个窗口卖票 实现Runnable接口的方式实现卖票
* 存在线程安全问题,待解决
* 正在解决中
* 1.问题:买票的过程中,出现了重票,错票 ---> 出现了线程的安全问题
* 2.问题出现的原因:当某一个线程操作车票的过程中,尚未操作完成时,其它的线程参与进来,也操作车票
* 3.如何解决:当一个线程a在操作ticket的时候,其它的线程不能参与进来,直到线程a操作完ticket时,
* 其它线程才可以开始操作ticket.这种情况即使线程a出现了阻塞,也不能改变
*
*/
class Window1 implements Runnable{
private int ticket = 100; //这里不用加static
@Override
public void run() {
while (true){
if(ticket>0){
try {
Thread.sleep(100);
}catch (InterruptedException e){
e.printStackTrace();
}
System.out.println(Thread.currentThread().getName()+"卖票,票号为:"+ticket);
ticket--;
}else {
break;
}
}
}
}
public class WindowTest1 {
public static void main(String[] args) {
Window1 window1 = new Window1();
Thread t1 = new Thread(window1);
Thread t2 = new Thread(window1);
Thread t3 = new Thread(window1);
t1.setName("窗口1");
t2.setName("窗口2");
t3.setName("窗口3");
t1.start();
t2.start();
t3.start();
}
}
15 同步代码块实现Runnable的线程安全问题
解决了线程安全问题
package com.hxut.java;
/**
* @author weijiangquan
* @date 2022/4/30 -20:18
* @Description 创建三个窗口卖票 实现Runnable接口的方式实现卖票
* 存在线程安全问题,待解决
* 正在解决中
* 1.问题:买票的过程中,出现了重票,错票 ---> 出现了线程的安全问题
* 2.问题出现的原因:当某一个线程操作车票的过程中,尚未操作完成时,其它的线程参与进来,也操作车票
* 3.如何解决:当一个线程a在操作ticket的时候,其它的线程不能参与进来,直到线程a操作完ticket时,
* 其它线程才可以开始操作ticket.这种情况即使线程a出现了阻塞,也不能改变
* 4.在java中,通过同步机制,来解决线程的安全问题
*
* 方式一:同步代码块
* synchronised(同步监视器){
* //需要被被同步的代码
* }
* 说明: 1.操作共享数据的代码,即为需要被同步的代码 ---不能包多也不能包少了
* 2.共享数据:多个线程共同操作的变量 比如:ticket就是共享数据.
* 3.同步监视器,俗称:锁 任何一个类的对象都可以充当锁
* 要求:多个线程必须公用同一把锁
补充:在实现Runable接口创建多线程的方式中,我们可以考虑使用this充当同步监视器
* 方式二:
* 5.使用同步的方式,解决了线程安全问题. ---好处
* 操作同步代码时,只能有一个线程参与,其它的线程等待.相当于是一个单线程的过程,效率低 --局限性
*
*/
class Window1 implements Runnable{
private int ticket = 100; //这里不用加static
Object obj = new Object();
@Override
public void run() {
while (true){
synchronized (obj) {
//这个时候可以使用this(这里的this是唯一的)
if(ticket>0){
try {
Thread.sleep(100);
}catch (InterruptedException e){
e.printStackTrace();
}
System.out.println(Thread.currentThread().getName()+"卖票,票号为:"+ticket);
ticket--;
}else {
break;
}
}
}
}
}
public class WindowTest1 {
public static void main(String[] args) {
Window1 window1 = new Window1();
Thread t1 = new Thread(window1);
Thread t2 = new Thread(window1);
Thread t3 = new Thread(window1);
t1.setName("窗口1");
t2.setName("窗口2");
t3.setName("窗口3");
t1.start();
t2.start();
t3.start();
}
}
16 同步代码块的处理继承Thread类的线程安全问题
没有共享数据是不会出现线程安全问题的,一定要注意
package com.hxut1;
/**
* @author weijiangquan
* @date 2022/4/30 -18:55
* @Description 创建三个窗口卖票:总的票数是100章
*
* 目前的这个存在线程的安全问题(后面解决)
*
*
*
*
* 在继承Thread类创建多线程的方式中,慎用this充当不同监视器,考虑使用当前类充当同步监视器
*
*/
class Window2 extends Thread{
private static int ticket = 100;
private static Object obj = new Object(); //这个时候就是唯一了
@Override
public void run() {
while (true){
// synchronized (this) 这里不能用this:this是t1,t2,t3三个对象
synchronized (obj) {
//这里可以使用Window2.class(后面讲反射的时候会说)(这里他是一个对象 后面将)
if(ticket>0){
try {
Thread.sleep(100);
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println(Thread.currentThread().getName()+"卖票,票号为"+ticket);
ticket--;
}else {
break;
}
}
}
}
}
public class WindowTest {
public static void main(String[] args) {
Window2 t1 = new Window2();
Window2 t2 = new Window2();
Window2 t3 = new Window2();
t1.setName("窗口1");
t2.setName("窗口2");
t3.setName("窗口3");
t1.start();
t2.start();
t3.start();
}
}
17 同步方法处理实现Runable的线程安全问题
package com.hxut1;
/**
* @author weijiangquan
* @date 2022/4/30 -23:41
* @Description 使用同步方法来解决Runnable接口的线程安全问题
*/
class Window3 implements Runnable{
private int ticket = 100; //这里不用加static
Object obj = new Object();
@Override
public void run() {
while (true){
show();
}
}
private synchronized void show(){
//同步监视器:this
if(ticket>0){
try {
Thread.sleep(100);
}catch (InterruptedException e){
e.printStackTrace();
}
System.out.println(Thread.currentThread().getName()+"卖票,票号为:"+ticket);
ticket--;
}
}
}
public class WindowTest3 {
public static void main(String[] args) {
Window3 window3 = new Window3();
Thread t1 = new Thread(window3);
Thread t2 = new Thread(window3);
Thread t3 = new Thread(window3);
t1.setName("窗口1");
t2.setName("窗口2");
t3.setName("窗口3");
t1.start();
t2.start();
t3.start();
}
}
18 同步方法处理继承Thread类的线程安全问题
package com.hxut1;
/**
* @author weijiangquan
* @date 2022/4/30 -23:53
* @Description 使用同步方法处理继承Thread类的方式中的线程安全问题
*
* 关于同步方法的总结:
* 1.同步的方法仍然涉及到同步监视器,只是不需要我们显式的声明
* 2.非静态的同步方法,同步监视器是:this
* 静态的同步方法,同步监视器是:当前类本身
*/
class Window4 extends Thread{
private static int ticket = 100;
@Override
public void run() {
while (true){
show();
}
}
private static synchronized void show(){
//同步监视器:这个时候的同步监视器是唯一的 Window4.class(这个时候的监视器)
// private synchronized void show(){ //同步监视器:t1,t2,t3.此种方式是错误的
if(ticket>0){
try {
Thread.sleep(100);
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println(Thread.currentThread().getName()+"卖票,票号为"+ticket);
ticket--;
}
}
}
public class WindowTest4{
public static void main(String[] args) {
Window4 t1 = new Window4();
Window4 t2 = new Window4();
Window4 t3 = new Window4();
t1.setName("窗口1");
t2.setName("窗口2");
t3.setName("窗口3");
t1.start();
t2.start();
t3.start();
}
}
总结:
/**
* @author weijiangquan
* @date 2022/4/30 -20:18
* @Description 创建三个窗口卖票 实现Runnable接口的方式实现卖票
* 存在线程安全问题,待解决
* 正在解决中
* 1.问题:买票的过程中,出现了重票,错票 ---> 出现了线程的安全问题
* 2.问题出现的原因:当某一个线程操作车票的过程中,尚未操作完成时,其它的线程参与进来,也操作车票
* 3.如何解决:当一个线程a在操作ticket的时候,其它的线程不能参与进来,直到线程a操作完ticket时,
* 其它线程才可以开始操作ticket.这种情况即使线程a出现了阻塞,也不能改变
* 4.在java中,通过同步机制,来解决线程的安全问题
*
* 方式一:同步代码块
* synchronised(同步监视器){
* //需要被被同步的代码
* }
* 说明: 1.操作共享数据的代码,即为需要被同步的代码
* 2.共享数据:多个线程共同操作的变量 比如:ticket就是共享数据.
* 3.同步监视器,俗称:锁 任何一个类的对象都可以充当锁
* 要求:多个线程必须公用同一把锁
* 方式二:同步方法
* 如果操作数据的代码完整的声明在一个方法中,我们不妨将此方法声明同步的
* 5.使用同步的方式,解决了线程安全问题. ---好处
* 操作同步代码时,只能有一个线程参与,其它的线程等待.相当于是一个单线程的过程,效率低 --局限性
*
*/
19 线程安全的单例模式之懒汉式
p437
package com.hxut1.java1;
/**
* @author weijiangquan
* @date 2022/5/1 -12:20
* @Description 使用同步机制单例模式中的懒汉式改写为线程安全的
*/
public class BankTest{
}
class Bank{
private Bank(){
}
private static Bank instance = null;
// synchronized 加上这个之后就是线程安全的了
public static synchronized Bank getInstance(){
if(instance == null){
instance = new Bank();
}
return instance;
}
}
class Bank1{
private Bank1(){
}
private static Bank1 instance = null;
// synchronized 加上这个之后就是线程安全的了
public static Bank1 getInstance(){
/*// 方式一 :效率稍差
synchronized (Bank1.class) {
if(instance == null){
instance = new Bank1();
}
return instance;
}*/
// 方式二:效率比上面那个高(建议写这个)
if(instance == null){
synchronized (Bank1.class) {
if(instance == null){
instance = new Bank1();
}
}
}
return instance;
}
}
20 多线程的死锁问题
package com.hxut1.java1;
/**
* @author weijiangquan
* @date 2022/5/1 -12:48
* @Description 线程的死锁问题
*
* 1.关于死锁的理解:不同的线程分别占用对方需要的同步资源不放弃,都在
* 等待对方放弃自己需要的同步资源,就形成了线程的死锁
* 2.说明:
* ① 出现死锁后,不会出现异常,不会出现提示,只是所有的线程都处于阻塞状态,无法继续
* ② 我们使用同步时,要避免出现死锁.
*
*/
public class ThreadTest {
public static void main(String[] args) {
StringBuffer s1 = new StringBuffer();
StringBuffer s2 = new StringBuffer();
// 用匿名的方式
new Thread(){
@Override
public void run() {
synchronized (s1){
s1.append("a");
s2.append("1");
try {
Thread.sleep(100);
} catch (InterruptedException e) {
e.printStackTrace();
}
synchronized (s2){
s1.append("b");
s2.append("2");
System.out.println(s1);
System.out.println(s2);
}
}
}
}.start();
// 通过实现接口的方式
new Thread(new Runnable() {
@Override
public void run() {
synchronized (s2){
s1.append("c");
s2.append("3");
try {
Thread.sleep(100);
} catch (InterruptedException e) {
e.printStackTrace();
}
synchronized (s1){
s1.append("d");
s2.append("4");
System.out.println(s1);
System.out.println(s2);
}
}
}
}).start();
}
}
上面的两个线程中进去之后都需要对方的锁,都不给,这样就会出现死锁的现象,只是说加了sleep之后,死锁的概率就会更高
21 Lock锁的方式解决线程安全问题
package com.hxut1.java1;
import java.util.concurrent.locks.ReentrantLock;
/**
* @author weijiangquan
* @date 2022/5/1 -13:12
* @Description 解决线程安全问题的方式三 ----JDK5.0新增
*/
class Window implements Runnable{
private int ticket = 100;
private ReentrantLock lock = new ReentrantLock(); //ctrl+p查看参数
@Override
public void run() {
while (true){
try {
if(ticket > 0){
//调用锁定的方法 lock()
lock.lock();
try {
Thread.sleep(100);
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println(Thread.currentThread().getName()+":售票,票号为"+ticket);
ticket--;
}else {
break;
}
}finally {
//3.调用解锁的方法 :unlock()
lock.unlock();
}
}
}
}
public class LockTest {
public static void main(String[] args) {
Window w = new Window();
Thread t1 = new Thread(w);
Thread t2 = new Thread(w);
Thread t3 = new Thread(w);
t1.setName("窗口1");
t2.setName("窗口2");
t3.setName("窗口3");
t1.start();
t2.start();
t3.start();
}
}
有点问题
面试题
* 1.面试题:synchronised与lock的异同
* 同:都可以解决线程安全问题
* 不同:synchronized机制在执行完相应的同步代码后,自动的释放同步监视器
* Lock需要手动的启动同步(lock()),同时结束同步也需要手动的实现(unlock())
* 2.优先使用顺序(看图片)
*
* 面试题:如何解决线程安全问题,有几种方式
*/
22 同步机制的课后练习
下面的代码存在线程安全问题
package com.hxut1.javae1;
/**
* @author weijiangquan
* @date 2022/5/1 -13:48
* @Description
* 银行有一个账户.
* 有两个储户分别向同一个账户存了3000元,每次存100,存3次,每次存完打印账户余额.
*
*
*
* 分析
* 1.是否时线程问题:是 两个储户线程
* 2.是否有共享数据? 有,账户(或账户余额)
* 3.是否需要考虑线程安全问题? 有
* 4.需要考虑如何解决线程安全问题?同步机制:有三种方式
*
*
*/
class Account{
private double balance;
public Account(double balance) {
this.balance = balance;
}
// 存钱的方法
public void deposit(double amt){
if(amt>0){
balance += amt;
try {
Thread.sleep(1000);
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println(Thread.currentThread().getName()+"存钱成功,余额为"+balance);
}
}
}
class Customer extends Thread{
private Account account;
public Customer(Account account) {
this.account = account;
}
@Override
public void run() {
for(int i =0;i<3;i++){
account.deposit(1000);
}
}
}
public class AccountTest {
public static void main(String[] args) {
Account account = new Account(0);
Customer customer = new Customer(account);
Customer customer1 = new Customer(account);
customer.setName("甲");
customer1.setName("乙");
customer.start();
customer1.start();
}
}
运行结果
线程安全问题处理以后
上面的同步方法中用的是同一个this,所以可以
23 线程的通信
package com.hxut2;
/**
* @author weijiangquan
* @date 2022/5/1 -14:15
* @Description 线程通信的列子
*
* 涉及到的三个方法:
* wait():一旦执行此方法,当前的线程就进入到阻塞状态,并释放同步监视器
* notify():一旦执行此方法,就会唤醒被wait的一个线程.如果有多个线程被wait,就唤醒优先级高的那个
* notifyAll():一旦执行此方法,就会唤醒所有被wait的线程
*
* 1.说明:
* 1.wait,notify,notifyAll这三个方法必须使用在同步代码块或同步方法中
* 2.三个方法的调用者必须是同步代码块或同步方法中的同步监视器,否者或出现异常
* 3.这三个方式是定义在Object类中的
*/
class Number implements Runnable{
private int number = 1;
@Override
public void run() {
while (true){
synchronized (this) {
notify();
if(number <= 100){
try {
Thread.sleep(10); //让它打印慢一点
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println(Thread.currentThread().getName()+":"+number);
number++;
try {
//使得调用wait方法的线程进入阻塞状态
wait(); //个人理解
} catch (InterruptedException e) {
e.printStackTrace();
}
}else {
break;
}
}
}
}
}
public class CommunicationTest {
public static void main(String[] args) {
Number number = new Number();
Thread t1 = new Thread(number);
Thread t2 = new Thread(number);
t1.setName("线程1");
t2.setName("线程2");
t1.start();
t2.start();
}
}
使用其它对象当同步监视器
注意:
24 sleep()和wait()的异同
面试题:
相同点:一旦执行,都可以使得当前的线程进入到阻塞状态
不同点:1.两个方法声明的位置不一样:Thread类中声明sleep(),Objcet类中声明wait() 2.调用的范围不同:sleep可以在任何需要的场景下调用,wait()必须在同步代码块或者同步方法中3.关于是否释放同步监视器的问题:如果两个方法都使用在同步代码或同步方法中,sleep()不会释放锁,wait()会释放锁
25 线程通信–生产者和消费者的问题–综合前面线程的所有知识(p443)
package com.hxut3;
/**
* @author weijiangquan
* @date 2022/5/1 -15:04
* @Description 经典的例题
*
* 分析:
* 1. 是否时多线程问题 ? 是,生产者线程,消费者线程
* 2. 是否有共享数据 ? 是,店员(或产品)
* 3. 如何解决线程安全问题 ? 同步机制,有三种方法
* 4. 是否涉及到线程的通信 ? 是
*
*/
// 店员
class Clerk{
private int productCount = 0;
/**
* 生产产品
*/
public synchronized void produceProduct() {
if(productCount < 20){
productCount++;
System.out.println(Thread.currentThread().getName()+":开始生产第"+productCount+"个产品");
notify(); //唤醒消费者
}else {
try {
wait();
} catch (InterruptedException e) {
e.printStackTrace();
}
//等待
}
}
/**
* 消费产品
*/
public synchronized void consumeProduct() {
if(productCount > 0){
System.out.println(Thread.currentThread().getName()+":开始消费第"+productCount+"产品");
productCount--;
notify();//唤醒生产者生产产品
}else {
try {
wait();
} catch (InterruptedException e) {
e.printStackTrace();
}
//等待
}
}
}
//生产者
class Producer extends Thread{
private Clerk clerk;
public Producer(Clerk clerk) {
this.clerk = clerk;
}
@Override
public void run() {
System.out.println(getName()+":开始生产产品.....");
while (true){
try {
sleep(20); //让他慢一点生产
} catch (InterruptedException e) {
e.printStackTrace();
}
clerk.produceProduct();
}
}
}
class Consumer extends Thread{
private Clerk clerk;
public Consumer(Clerk clerk) {
this.clerk = clerk;
}
@Override
public void run() {
System.out.println(getName()+":开始消费产品.....");
while (true){
try {
sleep(10); //让他慢一点生产
} catch (InterruptedException e) {
e.printStackTrace();
}
clerk.consumeProduct();
}
}
}
public class ProductTest {
public static void main(String[] args) {
Clerk clerk = new Clerk();
Producer p1 = new Producer(clerk);
p1.setName("生产者1");
Consumer c1 = new Consumer(clerk);
c1.setName("消费者1");
Consumer c2 = new Consumer(clerk);
c2.setName("消费者2");
p1.start();
c1.start();
c2.start();
}
}
本节有点疑惑,到时候可以再看看
26 创建多线程的方式三:实现Callable接口(P444)
JDK5.0新增的方式
package com.hxut4;
import com.sun.org.apache.xpath.internal.functions.FuncTranslate;
import java.util.concurrent.Callable;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.FutureTask;
/**
* @author weijiangquan
* @date 2022/5/1 -15:45
* @Description 创建线程的方式三:实现Callable接口. ---JDK 5.0 新增
*
* 1.创建一个实现Callable的实现类
*
*
* 如何理解实现Callable接口的方式创建多线程比实现Runnable接口创建多线程方式更强大?
* 1. call()可以有返回值
* 2. call()可以抛出异常.被外面的操作捕获,获取异常的信息
*
*
*/
class NumThread implements Callable{
//2.实现call方法,将此线程需要执行的操作声明再call()中
@Override
public Object call() throws Exception {
int sum = 0;
for (int i = 1; i <=100 ; i++) {
if(i%2==0){
System.out.println(i);
sum+=i;
}
}
return sum;
}
}
public class ThreadNew {
public static void main(String[] args) {
//3.创建Callable接口实现类的对象
NumThread numThread = new NumThread();
//4.将此Callable接口实现类的对象作为传递到FutureTask构造器中,创建FutureTask的对象
FutureTask futureTask = new FutureTask(numThread);
// 5.将FutureTask的对象作为参数传递到Thread类的构造器中,创建Thread对象,并调用start()
new Thread(futureTask).start();
try {
//6.获取Callable中call方法中的返回值(感兴趣救可以取,不感兴趣就不拿)
//get方法的返回值即为FutureTask构造器参数Callable实现类重写的call()返回值
Object sum = futureTask.get();
System.out.println(sum);
} catch (InterruptedException e) {
e.printStackTrace();
} catch (ExecutionException e) {
e.printStackTrace();
}
}
}
27 使用线程池的好处(图片一张)
在实际的开发中一般使用的是线程池的方式
28 创建多线程的方式4:使用线程池(p446)
package com.hxut5;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
/**
* @author weijiangquan
* @date 2022/5/1 -16:15
* @Description 创建线程的方式4:使用线程池
*
*
*/
class NumberThread implements Runnable{
@Override
public void run() {
for (int i = 0; i <100 ; i++) {
if(i%2==0){
System.out.println(Thread.currentThread().getName()+":"+i);
}
}
}
}
class NumberThread1 implements Runnable{
@Override
public void run() {
for (int i = 0; i <100 ; i++) {
if(i%2!=0){
System.out.println(Thread.currentThread().getName()+":"+i);
}
}
}
}
public class ThreadPool {
public static void main(String[] args) {
//1.提供指定线程数量的线程池
ExecutorService service = Executors.newFixedThreadPool(10);
//设置线程池的属性
// 2.执行指定的线程的操作,需要提供实现Runnable接口或Callable接口实现类的对象
service.execute(new NumberThread()); //适合使用于Runnable
service.execute(new NumberThread1());
// service.submit(); //适合使用于 Callable
//3.关闭连接池
service.shutdown();
}
}