day19_java多线程

已于 2022-03-25 08:27:27 修改
阅读量639 收藏
点赞数
分类专栏： Java 文章标签： java
于 2022-03-25 08:23:27 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_43327191/article/details/123726490
版权

Java多线程

1.线程的生命周期

JDK中用Thread.State类定义了线程的几种状态

一个线程在它的完整生命周期中通常要经历以下五种状态：

  1. 新建：当一个Thread类或其子类的对象被声明并创建时，新生的线程对象处于新建状态
  2. 就绪：处于新建状态的线程被start()后，将进入线程队列等待CPU时间片，此时他已经具备了运行条件，只是没分配到CPU资源
  3. 运行：当就绪状态的线程被调度并获得CPU资源时，便进入运行状态，run()方法定义了线程的操作和功能
  4. 阻塞：在某种特定情况下，被人为挂起或执行输入输出操作时，让出CPU并临时中止自己的执行，进入阻塞状态
  5. 死亡：线程完成了它的全部工作或线程被提前强制性地中止或出现异常导致结束

在这里插入图片描述

2.线程的同步

背景

线程之间共享数据，多个线程执行的不确定性引起执行效果的不稳定

解决方法：

在Java中，通过同步机制，解决线程的安全问题

方式一：同步代码块
/*
synchronized(同步监视器){
    //需要被同步的代码
}
说明：1.操作共享数据的代码，即为需要被同步的代码
     2.同步监视器：锁。任何一个类的对象，都可以充当锁
     	要求：多个线程必须要共用同一把锁
*/
同步代码块解决重写Runnable多线程安全问题
/*
 * 1.问题:多窗口卖票的过程中，出现了错票和重票---》》线程的安全问题
 * 2.原因：某个线程操纵车票的过程中，尚未操作完成时，其他线程也参与进来，操作车票
 * 3.解决方法：加锁；某个线程a在操作车票时，其他线程不能参与进来，知道线程a操作结束为止
 * 4.Java中:通过同步机制，解决线程安全问题
 */
public class MultiWindowTest1 {
    public static void main(String[] args) {
        NormClass n=new NormClass();
        Thread t1=new Thread(n);
        Thread t2=new Thread(n);
        Thread t3=new Thread(n);
        t1.setName("窗口1");
        t2.setName("窗口2");
        t3.setName("窗口3");
        t1.start();
        t2.start();
        t3.start();
    }
}

class NormClass implements Runnable{
    private int ticket=1000;
    Object obj=new Object();  //同步监视器
    @Override
    public void run() {
        while (true) {
            synchronized (obj) {
                if (ticket > 0) {
                    System.out.println(Thread.currentThread().getName() + "\t 票号为:" + ticket);
                    ticket--;
                } else {
                    break;
                }
            }
        }
    }
}
同步代码块解决继承Thread类多线程安全问题
public class MultiWindowTest {
    public static void main(String[] args) {
        MyThread t1=new MyThread();
        MyThread t2=new MyThread();
        MyThread t3=new MyThread();
        t1.setName("窗口1");
        t2.setName("窗口2");
        t3.setName("窗口3");
        t1.start();
        t2.start();
        t3.start();
    }
}

class MyThread extends Thread{
    private static int ticket=1000;
    private static Object obj=new Object();
    @Override
    public void run() {
        while (true) {
            synchronized (obj) {
                if (ticket > 0) {
                    System.out.println("窗口为:" + this.getName() + "\t 票数号码为:" + ticket);
                    ticket--;
                } else break;

            }
        }
    }
}
方式二：同步方法

如果操作共享数据的代码完整的声明在一个方法中，我们不妨将此方法声明为同步

同步方法解决重写Runnable多线程安全问题
public class WindowTest3 {
    public static void main(String[] args) {
        Mthread h=new Mthread();
        Thread t1=new Thread(h);
        Thread t2=new Thread(h);
        Thread t3=new Thread(h);
        
        t1.setName("窗口1");
        t2.setName("窗口2");
        t3.setName("窗口3");
        
        t1.start();
        t2.start();
        t3.start();
    }
}
class Mthread implements Runnable{
    private int ticket=1000;
    @Override
    public void run() {
        while (true){
                show();
                if(ticket==0) break;
            }
    }

    private synchronized void show() {  //默认当前的同步监视器为this
        if (ticket > 0) {
            System.out.println(Thread.currentThread().getName() + ": 当前票号为" + ticket);
            ticket--;
        }
    }
}
同步方法解决继承Thread类多线程安全问题
public class WindowTest4 {
    public static void main(String[] args) {
        MThread4 t1=new MThread4();
        MThread4 t2=new MThread4();
        MThread4 t3=new MThread4();
        t1.setName("窗口1");
        t2.setName("窗口2");
        t3.setName("窗口3");

        t1.start();
        t2.start();
        t3.start();
    }
}

class MThread4 extends Thread{
    private static int ticket=1000;
    @Override
    public void run() {
        while (true){
            show();
            if(ticket==0) break;
        }
    }
    //注意：1.此时同步的方法需添加static,否则会报错,应为多个线程之间要共用同一把锁
    //	   2.静态方法无法调用this,此时充当同步监视器的是当前类
    private static synchronized void show(){
        if(ticket>0){
            System.out.println(Thread.currentThread().getName()+" :当前票号"+ticket);
            ticket--;
        }
    }
}
总结：
  1. 同步方法的方式仍然涉及到同步监视器，只是不需要我们显式地声明
  2. 非静态的同步方法，同步监视器：this
  3. 静态的同步方法，同步监视器：当前类本身
应用：

线程同步解决懒汉式单例设计的安全问题

同步代码块方式：
class SingleTest{

    private static SingleTest instance=null;

    private SingleTest(){}

    public static SingleTest getInstance(){
        //方式1：效率较低
//        synchronized (SingleTest.class) {
//            if (instance == null) {
//                instance = new SingleTest();
//            }
//            return instance;
//        }
        //方式2：效率较高
        synchronized (SingleTest.class){
            if(instance==null) {
                synchronized (SingleTest.class) {
                    if (instance == null) {
                        instance = new SingleTest();
                    }
                }
            }
            return instance;
        }
    }
}
同步方法方式：
class SingleTest{

    private static SingleTest instance=null;

    private SingleTest(){}

    public static synchronized SingleTest getInstance(){
        if(instance==null){
            instance=new SingleTest();
        }
        return instance;
    }
}

3.线程的死锁问题

死锁：
  • 不同的线程分别占用对方需要的同步资源不放弃，都在等待对方放弃自己需要的同步资源，就形成了线程的死锁
  • 出现死锁后，不会出现异常，不会出现提示，只是所有的线程都处于阻塞状态，无法继续

线程死锁示例：

public class DeadLockTest1 {
    public static void main(String[] args) {

        StringBuffer s1 = new StringBuffer();
        StringBuffer s2 = new StringBuffer();

        new Thread() {
            @Override
            public void run() {
                synchronized (s1) {
                    try {
                        Thread.sleep(100);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                    s1.append('a');
                    s2.append('1');
                    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) {
                    try {
                        Thread.sleep(100);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                    s1.append('c');
                    s2.append('3');
                    synchronized (s1) {
                        s1.append('d');
                        s2.append('4');
                        System.out.println(s1);
                        System.out.println(s2);
                    }
                }
            }
        }).start();

    }
}
如何解决死锁问题：
  1. 专门的算法，原则避开死锁的可能性
  2. 尽量减少同步资源的定义
  3. 尽量避免嵌套同步

4.Lock锁解决线程安全问题

  • JDK5.0开始，Java提供了更强大的线程同步机制：显示定义同步锁实现同步。同步锁使用Lock对象充当。
  • java.util.concurrent.locks.Lock接口是控制多个线程对共享资源进行访问的工具。锁提供了对共享资源的独占访问，每次只能有一个线程对Lock对象加锁，线程访问共享资源之前应先获得Lock对象
  • ReentrantLock类实现了Lock,它拥有与synchronized相同的并发性和内存语义，在实现线程安全的控制中，比较常用的是ReentrantLock,可以显示加锁、释放锁。
使用格式

在这里插入图片描述

实例
import java.util.concurrent.locks.ReentrantLock;

public class Exe2 {
	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();
	}
}


class Window implements Runnable{
	private int ticket=100;
	//显示定义同步锁对象实现线程同步
	private ReentrantLock lock=new ReentrantLock();
	@Override
	public void run() {
		// TODO Auto-generated method stub
		while(true){
			lock.lock();  //加锁
			try{
			if(ticket>0){
				try {
					Thread.sleep(100);
				} catch (InterruptedException e) {
					// TODO Auto-generated catch block
					e.printStackTrace();
				}
				System.out.println(Thread.currentThread().getName()+"售票,票号为:"+ticket);
				ticket--;
			}
			else
				break;
			}
			finally{
			lock.unlock(); //解锁
			}
		}
		
	}
}
syschronized机制与lock机制的异同点
  1. 相同点：
    1. 两者都可以实现线程同步，解决线程安全问题
  2. 不同点
    1. synchronized机制执行完相应的代码逻辑后，会自动释放同步监视器
    2. lock机制需手动实现加锁(lock())和解锁(unlock())

5.线程的通信

相关的API
  • wait():一旦执行此方法，当前线程会进入阻塞状态，并释放同步监视器
  • notify():一旦执行此方法，就会唤起被wait的一个线程，如果有多个线程被wait,则唤醒优先级高的那一个
  • notifyAll():一旦执行此方法,就会唤醒所有被wait的进程
注意：
  • 上面的三个方法只能使用在同步代码块或同步方法中
    • lock机制使用其他的方法进行进程通信
  • 上面三个方法的调用者必须是同步代码块或同步方法中的同步监视器
  • 上面三个方法是定义在java.lang.Object中
实例
/*
 * 线程之间通信:
 * 	实现两个线程交替打印1~100数字
 */
public class Exe4 {
	public static void main(String[] args) {
		ThreadMy w=new ThreadMy();
		Thread t1=new Thread(w);
		Thread t2=new Thread(w);
		t1.setName("线程1");
		t2.setName("线程2");
		t1.start();
		t2.start();
	}
}

class ThreadMy implements Runnable{
	private int number=1;
	@Override
	public void run() {
		// TODO Auto-generated method stub
		while(true){
			synchronized (this) {  //实现线程同步
				notify();  //唤起当前阻塞的线程
				//两个及以上阻塞的线程全部唤起使用 notifyAll
			if(number<=100){
				System.out.println(Thread.currentThread().getName()+":"+number);
				number++;
				try {
					wait();   //当前线程阻塞,同时会释放同步锁
				} catch (InterruptedException e) {
					// TODO Auto-generated catch block
					e.printStackTrace();
				}
			}
			else
				break;
			}
		}
	}
}
常见面试题
1. sleep()与wait()的异同

  • 相同点：

    • 执行对应方法，都可以使当前线程进入阻塞状态

  • 不同点：

    • 两个方法申明的位置不同：Thread()类中申明sleep()，Object类中申明wait()

    • 调用的范围要求不同：

      • sleep()可以在任何场景下调用
      • wait()必须在同步代码块或同步方法中调用

    • sleep()不会释放同步监视器,wait()会释放同步监视器

6. JDK5.0新增线程创建方式

6.1 实现Callable接口

  • 与使用Runnable相比,其功能更强大

    • 相比于run()方法，可以有返回值
    • 方法可以抛出异常
    • 支持泛型的返回值
    • 需要借助FutureTask类，比如获取返回结果

  • Future接口

    • 可以对具体Runnable、Callable任务的执行结果进行取消、查询是否完成、获取结果等。
    • FutureTask是Future接口的唯一实现类
    • FutureTask同时实现了Runnable、Future接口。它既可以作为Runnable被线程执行，又可以作为Future得到Callable的返回值。
实例
import java.util.concurrent.Callable;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.FutureTask;

/*
 * 实现Callable接口方式实现多线程
 */
public class Exe6 {
	public static void main(String[] args) {
		//3.实例化Callable实现类对象
		ThreadNew t=new ThreadNew();
		//借助FutureTask获取返回值
		//4.将Callable实现类对象作为参数实例化FutureTask实现类对象
		FutureTask f=new FutureTask(t);//Callable实现类对象作为参数
		//线程启动
		//5.FutureTask实现类对象作为参数实例化Thread对象,调用start()启动线程
		new Thread(f).start();
		try {
			//6. 如果要获取返回值,通过FutureTask类的get()获取
			Object sum = f.get(); //通过get()获取线程返回值
			System.out.println("总和:"+sum);
		
		} catch (InterruptedException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		} catch (ExecutionException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		}
		
}
}


//1.创建Callable接口的实现类
class ThreadNew implements Callable{
	private int sum=0;
	//2.重写call(),线程要执行的操作为方法的方法体
	@Override
	public Object call() throws Exception {
		for(int i=0;i<100;i++){
			if(i%2==0) sum+=i;
		}
		return sum;  //自动装箱为Integer
	}
}
6.2 使用线程池

在这里插入图片描述

在这里插入图片描述

实例：
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;

/*
 * 使用线程池的方式来实现多线程
 */
public class Exe7 {
	public static void main(String[] args) {
		//1.提供指定数量的线程池
		ExecutorService service=Executors.newFixedThreadPool(10);
		//2.执行指定类操作,需提供一个实现Runnable或Callable接口实现类对象
		service.execute(new Thread1());  //执行线程
		service.execute(new Thread2());
//		service.submit()   //callable接口使用submit()
		//3.关闭连接池
		service.shutdown(); //关闭线程池
	}
}


class Thread1 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 Thread2 implements Runnable{
	@Override
	public void run() {
		for(int i=0;i<100;i++){
			if(i%2!=0)
				System.out.println(Thread.currentThread().getName()+":"+i);
		}
		
	}
}
远古穷鬼
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
Java学习路线：day19
01-20
文章目录第8章 多线程线程的生命周期线程的同步同步代码块处理实现Runnable的线程安全问题同步代码块处理继承Thread类的线程安全问题同步方法处理实现Runnable的线程安全问题同步方法处理继承Thread类的线程安全问题...
java视频教程Day01 免费
08-26
11． Multi-Thread（多线程） 12． I/O and File (输入/输出流及文件) 13． Networking (网络编程) 以上教学过程中贯穿一个银行项目，根据每天所学的东西不断完善 J2EE部分 14． JDBC Overview and Using JDBC ...
java多线程间的通信传值_Java 多线程之间的通信
weixin_42514627的博客
02-24 473
一个线程送水，一个线程出水:多个线程操作同一个资源，但操作的动作不同。两个线程操作同一资源，但操作的动作不一样。两个方法packagecn.itcast.day5.thread;//一进一出public class线程通信{public static voidmain(String[] args){Resouce resouce= newResouce();Input input= newInpu...
Java多线程编程
chenmi123321的博客
10-19 952
java
多线程抢票_java多线程下模拟抢票
weixin_39672160的博客
01-13 828
我们设置三个对象分别同时抢20张票,利用多线程实现.public class Web123506 implements Runnable{private int ticteksNums=20;//票数@Overridepublic void run() {while (true){if(ticteksNums<0){break;}/* try {//睡眠Thread.sleep(200);}...
day19_线程
m0_58073753的博客
03-14 542
day19_线程基础
CoreJava笔记
03-11
CoreJava笔记 CoreJava DAY01 Java概述 1 CoreJava DAY02 数据类型和控制结构 6 CoreJava DAY03 数组 11 CoreJava DAY04 15 ...CoreJava DAY19-20 多线程 85 CoreJava DAY21-22 IO 95 CoreJava DAY23 网络编程 107
达内 CoreJava老师笔记汇总
11-25
CoreJava DAY01 Java概述 1 CoreJava DAY02 数据类型和控制结构 10 CoreJava DAY03 数组 20 CoreJava DAY04 27 ...CoreJava DAY19-20 多线程 154 CoreJava DAY21-22 IO 174 CoreJava DAY23 网络编程 197
达内Java培训-CoreJava全程笔记（WORD唐亮版）
07-20
CoreJava DAY01 Java概述 1 CoreJava DAY02 数据类型和控制结构 6 CoreJava DAY03 数组 11 CoreJava DAY04 15 ...CoreJava DAY19-20 多线程 85 CoreJava DAY21-22 IO 95 CoreJava DAY23 网络编程 107
java方法重写（重点讲），方法重载
weixin_46281068的博客
04-27 1063
一、方法重载定义：一个类中，出现多个方法的名称相同，但是它们的形参列表是不同的，那么这些方法就称为方法重载了。注意：一个类中，只要一些方法的名称相同、形参列表不同，那么它们就是方法重载了，其它的都不管（如:修饰符，返回值类型是否一样都无所谓）。形参列表不同指的是:形参的个数、类型、顺序不同，不关心形参的名称。应用场景：开发中我们经常需要为处理一类业务，提供多种解决方案，此时用方法重载来设计是很专业的。
Day25-Java基础之常用类1
m0_46053885的博客
04-27 973
同时我们发现Math类中的方法都是静态的，因此在使用的时候我们可以直接通过类名去调用。对于计算机而言，其实是没有数据类型的概念的，都是0101010101，数据类型是编程语言自己规定的，所以在实际存储的时候，先把具体的数字变成二进制，每32个bit为一组，存储在数组中。比较内存地址值一般情况下是没有意义的，我们希望比较的是对象的属性，如果两个对象的属性相同，我们认为就是同一个对象；如果我们的数据是一个浮点类型的数据，有的时候计算机并不会将这个数据完全转换成一个二进制数据，而是将这个将其转换成一个无限的。
Spring Cloud——LoadBalancer
最新发布
????
05-01 594
这里只是简单的讲解了一下LoadBalancer如何使用，因为实际上我们使用的不是很多，主要还是使用OpenFeign。
d15(136-148)-勇敢开始Java，咖啡拯救人生
m0_73459387的博客
04-28 992
对象哈希值的特点：同一个对象调用hashCode()返回的哈希值相同；HashMap的键依赖hashCode方法和equals方法保证键的唯一，存储自定义类型的对象时，重写这两个方法。实际上，Set系列集合的底层就是基于Map实现的，只是Set集合中的元素要键数据，不要值数据。当12个位置都占满时就会扩容，大约扩容为原来的二倍，再把原数组数据转移到新数组。使用迭代器遍历集合时，又同时在删除集合中的数据，程序就会出现并发修改异常的错误。基于哈希表实现，每个键值对额外多了一个双链表的机制，记录元素顺序（保证。
Java解决最长公共前缀
无人罪的博客
04-28 289
编写一个函数来查找字符串数组中的最长公共前缀。如果不存在公共前缀，返回空字符串""。
【一步一步了解Java系列】：探索Java基本类型与C语言的区别
2302_81249757的博客
04-29 799
​​喜欢的一句话： 常常会回顾努力的自己，所以要为自己的努力留下足迹。作者：小闭。
Spring cloud原理详解
qq_33449977的博客
04-28 389
想象一下，你开了一家餐馆，一开始只卖汉堡，后来生意火了，你又增加了炸鸡、披萨、冰淇淋各种摊位，每个摊位就是一个微服务，它们各自独立工作，但又得相互配合。有时候，某个服务可能太忙了，电话老打不通，这时候Spring Cloud还有个叫Hystrix的断路器，它会说：“嘿，别打了，那边线路忙，我给你个备用方案或者告诉你稍后再试。至于餐馆运营情况，Spring Cloud Sleuth和Zipkin这些工具，就像监控摄像头，记录服务间的每一次交互，方便你查看哪里出了问题，优化服务流程。
公考学习平台|基于SprinBoot+vue的公考学习平台(源码+数据库+文档)
weixin_66413741的博客
04-30 876
本共享汽车管理系统有管理员和用户。管理员功能有个人中心，用户管理，投放地区管理，汽车信息管理，汽车投放管理，汽车入库管理，使用订单管理，汽车归还管理。用户可以在注册登录，可以对汽车进行使用产生订单，还可以归还。因而具有一定的实用性。本站是一个B/S模式系统，采用Spring Boot框架，MYSQL数据库设计开发，充分保证系统的稳定性。系统具有界面清晰、操作简单，功能齐全的特点，使得共享汽车管理系统管理工作系统化、规范化。
埃氏筛选-判断素数
qq_45706306的博客
04-27 235
筛选：从最小的质数2开始，将它的所有倍数标记为合数（非质数），即把 isshushu 数组中对应索引位置的值设置为 true。计数：在筛选过程中，每当遇到一个未被标记为合数的数（即 isshushu 数组中对应值为 false 的数），则它就是一个质数，增加质数计数器 count 的值。返回结果：当所有小于 n 的数都经过筛选后，返回质数计数器 count 的值，即小于 n 的质数数量。通过这种方式，代码能够高效地找出并计算给定范围内质数的数量，避免了逐一检查每个数是否为质数的低效方法。
java DAY_OF_MONTHY
07-22
Java中的DAY_OF_MONTH常量是一个字段，用于表示一个日期中的月份中的天数。它位于java.util.Calendar类中，可以通过Calendar类的get方法来获取： ```java import java.util.Calendar; public class Main { public...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值