Java多线程(下篇)

最新推荐文章于 2022-06-14 21:26:02 发布
最新推荐文章于 2022-06-14 21:26:02 发布
阅读量493 收藏 2
点赞数
分类专栏： Java基础 文章标签： java 线程安全 多线程
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/abc6368765/article/details/76796607
版权

一、死锁

1.同步锁 解决了线程安全问题，但会造成性能低下，还可能会引发一个问题（罕见）：死锁

2.例子

a.一个地痞子死后，来到了地狱，到了吃饭的时候，他发现饭桌上面的饭菜非常丰盛，然后好多人围着一张大桌子，一起吃饭，饭菜都上齐了，非常美味，
他们非常饿，开吃吧…但是只有两支筷子，而且是两个人同时各拿一支筷子…如果没有人愿意共享自己的筷子，那么他们就只能饿着…看着…馋着…留着口水.煎熬着…

b.爸爸说：“给我成绩单，就给你零花钱”，儿子说：“给我零花钱，就给你成绩单”，如果两人互不相让…

3.多个线程之间彼此占用对方想使用的资源

4.要使用非常规的手段演示b

5.分析b案例

a.爸爸要成绩单 和 儿子要零花钱 这两个事情是同时发生的 多线程

b.爸爸是一个线程 儿子是一个线程

c.嵌套锁 + 交叉锁


public class Son extends Thread {

    public void run() {

        for (int i = 0; i < 3; i++) {
            synchronized (MyLock.lock02_reportCart) {
                System.out.println("son：儿子有成绩单");
                try {
                    com.afinalstone.MyLock.lock02_reportCart.wait(5000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                synchronized (MyLock.lock02_money) {
                    System.out.println("son：儿子想要爸爸的零花钱");
                }
            }
        }

    }

}

public class Father extends Thread {

    public void run() {
        for (int i=0; i<3; i++){
            synchronized (MyLock.lock02_money) {
                System.out.println("Father：爸爸有零花钱");
                try {
                    MyLock.lock02_money.wait(5000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
            synchronized (MyLock.lock02_reportCart) {
                System.out.println("Father：爸爸想要儿子的成绩单");
            }
        }


    }
}


public class MyLock {
    public static Object lock02_money = new Object();
    public static Object lock02_reportCart = new Object();
}

public class TestFatherSon {

    public static void main(String[] args) {
        new Father().start();
        new Son().start();
    }

}

二、解决死锁问题

1.同步代码块，一旦某个线程执行了这个同步代码块，该代码块会自动上锁，当前线程把代码块里面所有的代码全部执行完，锁会自动解开

2.解决思路：不能等着自然解锁，而是有程序员主动的、及时的释放锁(解锁-开锁)

3.开锁的方法：wait() wait(long) 开锁 在Object类中

4.该方法的作用：

a.释放锁

b.让当前线程休息

5.sleep()方法也可以让当前线程休息，没有释放锁的功能

6.任意对象都有一把锁，也有解锁的方法

三、notify方法

1.无参的wait()一旦执行了，会造成当前线程一直睡…..

2.notify() 唤醒某个被wait()的线程

3.自身无法唤醒自身

4.wait()和notify()必须使用的是同一把锁

5.之前的同步代码块是解决线程安全问题，还可以实现线程间的通信（打电话、发消息）

6.结合wait()和notify()并依靠同一把锁，可以实现线程间的通信(可不是互相发消息)。
锁相当于中间人的作用，两个线程必须用同一把锁(认识同一个中间人)


public class Thread1 extends Thread{
    public void run() {

        for (int i = 1; i <= 20; i++) {
            synchronized (MyLock.lock01_thread) {
                System.out.println(i);
                if(i%5==0)
                {
                    try {
                        MyLock.lock01_thread.notify();
                        MyLock.lock01_thread.wait();
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }
            }       
        }
    }
}

public class Thread2 extends Thread{        //唤醒Thread1的线程
    public void run(){
        for(int j=0;j<10;j++){
            synchronized (MyLock.lock01_thread) {
                try {
                    MyLock.lock01_thread.notify();
                    System.out.println("唤醒");
                    MyLock.lock01_thread.wait();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }

            }
        }
    }
}

public class TestWaitNotify {

    public static void main(String[] args) {
        Thread1 t1=new Thread1();
        t1.start();
        Thread2 t2=new Thread2();
        t2.start();
    }

}

四、sleep方法使用实例


public class ThreadSleep {
    public static void main(String args[]) {
        MyThread thread = new MyThread();
        thread.start();//调用start()方法启动新开辟的线程
        try {
            /*Thread.sleep(10000);
            sleep()方法是在Thread类里面声明的一个静态方法，因此可以使用Thread.sleep()的格式进行调用
            */
            /*MyThread.sleep(10000);
            MyThread类继承了Thread类，自然也继承了sleep()方法，所以也可以使用MyThread.sleep()的格式进行调用
            */
            /*静态方法的调用可以直接使用“类名.静态方法名”
              或者“对象的引用.静态方法名”的方式来调用*/
            MyThread.sleep(10000);
            System.out.println("主线程睡眠了10秒种后再次启动了");
            //在main()方法里面调用另外一个类的静态方法时，需要使用“静态方法所在的类.静态方法名”这种方式来调用
            /*
            所以这里是让主线程睡眠10秒种
            在哪个线程里面调用了sleep()方法就让哪个线程睡眠，所以现在是主线程睡眠了。
            */
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        //thread.interrupt();//使用interrupt()方法去结束掉一个线程的执行并不是一个很好的做法
        thread.flag = false;//改变循环条件，结束死循环
        /**
         * 当发生InterruptedException时，直接把循环的条件设置为false即可退出死循环，
         * 继而结束掉子线程的执行，这是一种比较好的结束子线程的做法
         */
        /**
         * 调用interrupt()方法把正在运行的线程打断
         相当于是主线程一盆凉水泼上去把正在执行分线程打断了
         分线程被打断之后就会抛InterruptedException异常，这样就会执行return语句返回，结束掉线程的执行
         所以这里的分线程在执行完10秒钟之后就结束掉了线程的执行
         */
    }
}

class MyThread extends Thread {
    boolean flag = true;// 定义一个标记，用来控制循环的条件

    public void run() {
        /*
         * 注意：这里不能在run()方法的后面直接写throw Exception来抛异常， 
         * 因为现在是要重写从Thread类继承而来的run()方法,重写方法不能抛出比被重写的方法的不同的异常。
         *  所以这里只能写try……catch()来捕获异常
         */
        while (flag) {
            System.out.println("==========" + new Date().toLocaleString() + "===========");
            try {
                /*
                 * 静态方法的调用格式一般为“类名.方法名”的格式去调用 在本类中声明的静态方法时调用时直接写静态方法名即可。 当然使用“类名.方法名”的格式去调用也是没有错的
                 */
                // MyThread.sleep(1000);//使用“类名.方法名”的格式去调用属于本类的静态方法
                sleep(1000);//睡眠的时如果被打断就会抛出InterruptedException异常
                // 这里是让这个新开辟的线程每隔一秒睡眠一次，然后睡眠一秒钟后再次启动该线程
                // 这里在一个死循环里面每隔一秒启动一次线程，每个一秒打印出当前的系统时间
            } catch (InterruptedException e) {
                /*
                 * 睡眠的时一盘冷水泼过来就有可能会打断睡眠 
                 * 因此让正在运行线程被一些意外的原因中断的时候有可能会抛被打扰中断(InterruptedException)的异常
                 */
                return;
                // 线程被中断后就返回，相当于是结束线程
            }
        }
    }
}

五、join方法使用实例

public class TestThreadJoin {
    public static void main(String args[]) {
        MyThread_Join thread2 = new MyThread_Join("MyThread_Join");
        // 在创建一个新的线程对象的同时给这个线程对象命名为mythread
        thread2.start();// 启动线程
        try {
            thread2.join();// 调用join()方法合并线程，将子线程mythread合并到主线程里面
            // 合并线程后，程序的执行的过程就相当于是方法的调用的执行过程
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        for (int i = 0; i <= 5; i++) {
            System.out.println("I am main Thread");
        }
    }
}

class MyThread_Join extends Thread {
    MyThread_Join(String s) {
        super(s);
        /*
         * 使用super关键字调用父类的构造方法 
         * 父类Thread的其中一个构造方法：“public Thread(String name)” 
         * 通过这样的构造方法可以给新开辟的线程命名，便于管理线程
         */
    }

    public void run() {
        for (int i = 1; i <= 5; i++) {
            System.out.println("I am a\t" + getName());
            // 使用父类Thread里面定义的
            //public final String getName()，Returns this thread's name.
            try {
                sleep(1000);// 让子线程每执行一次就睡眠1秒钟
            } catch (InterruptedException e) {
                return;
            }
        }
    }
}

六、yield方法使用实例

public class TestThreadYield {
    public static void main(String args[]) {
        MyThread_Yield t1 = new MyThread_Yield("t1");
        /* 同时开辟了两条子线程t1和t2，t1和t2执行的都是run()方法 */
        /* 这个程序的执行过程中总共有3个线程在并行执行，分别为子线程t1和t2以及主线程 */
        MyThread_Yield t2 = new MyThread_Yield("t2");
        t1.start();// 启动子线程t1
        t2.start();// 启动子线程t2
        for (int i = 0; i <= 5; i++) {
            System.out.println("I am main Thread");
        }
    }
}

class MyThread_Yield extends Thread {
    MyThread_Yield(String s) {
        super(s);
    }

    public void run() {
        for (int i = 1; i <= 5; i++) {
            System.out.println(getName() + "：" + i);
            if (i % 2 == 0) {
                yield();// 当执行到i能被2整除时当前执行的线程就让出来让另一个在执行run()方法的线程来优先执行
                /*
                 * 在程序的运行的过程中可以看到，
                 * 线程t1执行到(i%2==0)次时就会让出线程让t2线程来优先执行 
                 * 而线程t2执行到(i%2==0)次时也会让出线程给t1线程优先执行
                 */
            }
        }
    }
}

七、生产者消费者模式

1.研究什么问题？农夫不停的摘水果放到框里，小孩不停的从框里拿水果吃

2.生产速度 跟 消费速度

3.农夫和小孩都需要依靠wait()和notify()调节进度


public class Child extends Thread {

    public void run() {
        while (true) {
            synchronized (Factory.numOfFactory) {
                if(Factory.numOfFactory.size()==0)
                {
                    try {
                        Factory.numOfFactory.wait();
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }
                Factory.numOfFactory.remove(0);
                Factory.numOfFactory.notify();
                System.out.println("小孩吃了一个水果，还有" + Factory.numOfFactory.size() + "个水果");
                try {
                    Thread.sleep(10);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        }
    }
}

public class FruitFactory extends Thread{

    public void run(){
        while (true) {
            synchronized (Factory.numOfFactory) {

                if(Factory.numOfFactory.size()>=10)
                {
                    try {
                        Factory.numOfFactory.wait();
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }
                Factory.numOfFactory.add(1);
                Factory.numOfFactory.notify();
                System.out.println("水果场生产一个水果，现在有" + Factory.numOfFactory.size()
                        + "个水果");
                try {
                    Thread.sleep(500);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        }
    }

}

public class Factory {
    public static ArrayList<Integer> numOfFactory = new ArrayList<>();  //规定长度不能超过30
}

public class TestChild_FruitFactory {

    public static void main(String[] args) throws Exception {
        new FruitFactory().start();
        new Child().start();
    }

}

八、单例设计模式

1.实例化 实例

2.单个实例 只能创建出来一个对象

3.步骤

a.限制构造方法

b.把创建对象的代码放到一个静态的方法中并返回这个对象

c.增加一个静态属性，当该属性的值为null时才创建对象

4.懒汉式这种写法是否存在线程安全问题？会存在

5.只需要把getInstance方法改为同步方法即可解决线程安全问题

6.饿汉式没有线程安全问题，因此推荐使用

7.一般情况，懒汉式更常见

//饿汉式
public class Student_hunger {
    private static Student_hunger s=new Student_hunger();

    private Student_hunger() {
    }

    public static Student_hunger getInstance()
    {
        return s;
    }
}

//懒汉式
public class Student_lazybones {

    private static Student_lazybones s=null;

    private Student_lazybones() {
    }

    public synchronized static Student_lazybones getInstance()
    {
        if(s==null)
        {
            s=new Student_lazybones();
        }
        return s;
    }

}
public class ThreadStudent extends Thread{

    public void run(){

        for (int i = 0; i < 10; i++) {
            Student_lazybones s= Student_lazybones.getInstance();
            System.out.println(s.hashCode());
        }

    }
}

public class Main {

    public static void main(String[] args) {
        testLazyBones();
        testHunger();
        testThreadStudent();
    }

    private static void testLazyBones(){
        Student_lazybones s1= Student_lazybones.getInstance();
        System.out.println(s1.hashCode());

        Student_lazybones s2= Student_lazybones.getInstance();
        System.out.println(s2.hashCode());
    }

    private static void testHunger(){
        Student_hunger ss1= Student_hunger.getInstance();
        System.out.println(ss1.hashCode());

        Student_hunger ss2= Student_hunger.getInstance();
        System.out.println(ss2.hashCode());
    }

    private static void testThreadStudent(){
        for (int i = 0; i < 3; i++) {
            new ThreadStudent().start();
        }
    }
}

项目地址：传送门

AFinalStone
关注
  • 0
    点赞
  • 踩
  • 2
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
多线程(生产者与消费者)
梦不遥远的专栏
12-18 436
需求：有一个箱子，一个男孩往里面放水果，等到箱子里满了以后，一个女孩去箱子里去水果，等箱子里水果没了，男孩再放水果进去。 1.定义一个Box类. package org.demo; import java.util.LinkedList; public class Box { /
多线程之水果拼盘问题（java--信号量（semaphore）实现）
leoma2012的博客
05-23 1036
题目 小明想吃水果拼盘，需要先买到几种水果，然后做成拼盘。 解析 先买到香蕉、橘子和苹果三种水果，然后再做拼盘。为三种水果的线程各自分配一个信号量，然后购买完成后释放信号量给拼盘。 因为获得信号量前会被阻塞，所以在拼盘获得足够的信号量之前是不会做出来的。 acquire和release方法 public void acquire() 从此信号量获取一个许可，在提供一个许可前一直将线程阻塞，否则线...
一文搞定Java并发编程面试考点
weixin_33979745的博客
01-25 3921
2019独角兽企业重金招聘Python工程师标准>>> ...
李洪强经典面试题41-iOS选择题
a359798678的博客
10-25 842
1.及时聊天app不会采用的网络传输方式是 DA UDP B TCP C Http D FTP 2.下列技术不属于多线程的是 AA Block B NSThread C NSOperation D GCD 3.线程和进程的区别不正确的是 BA 进程和线程都是由操作系统所体会的程序运行的基本单元B 线程之间有单独的地址空间C 进程和线程的主要差别在于它们是不同的操...
Hadoop自测题及参考答案
三人行，必有我师焉。
06-18 1万+
单选题 1、与其他几项不同的是 A. Mesos B. Mongodb C. Corona D. Borg E. YARN 注：其他几项都是资源统一管理系统或者资源统一调度系统，而 Mongodb一种非关系型数据库。 2、[java基础] 以下不属于线程安全的数据结构是 A. HashMap B. HashTable C. CopyOnWriteArrayL
java多线程_java多线程下变量共享_
09-30
本篇文章将深入探讨Java多线程下变量共享的问题以及解决策略。 在Java中，线程共享变量可以通过两种方式实现：静态成员变量和实例成员变量。静态成员属于类，所有该类的实例都可以访问，因此在多线程环境下默认共享...
Java多线程工具篇BlockingQueue的详解
08-26
Java多线程工具篇BlockingQueue的详解 BlockingQueue是Java多线程工具篇中的一种高效安全的队列类，在多线程环境中扮演着关键角色。它能够高效解决多线程中数据传输的问题，使得数据由队列的一端输入，从另外一端...
Java多线程下解决资源竞争的7种方法详解
08-25
Java多线程下解决资源竞争的7种方法详解 Java 多线程编程中，资源竞争是一个非常重要的问题。随着多线程编程的增加，资源竞争的问题也变得越来越复杂。解决资源竞争的方法有很多种，这篇文章将介绍 Java 中解决...
Java多线程编程实战指南(核心篇)
07-17
Java多线程编程实战指南(核心篇) 高清pdf带目录 随着现代处理器的生产工艺从提升处理器主频频率转向多核化，即在一块芯片上集成多个处理器内核（Core），多核处理器（Multicore Processor）离我们越来越近了――如今...
Java多线程下的单例模式参考
09-02
本篇将探讨如何在Java多线程下实现单例模式，重点关注`synchronized`关键字和`java.util.concurrent.locks.Lock`接口的`ReentrantLock`类。 首先，我们来看传统的懒汉式单例模式，它延迟初始化，只有在第一次调用`...
题解报告：hdu 1263 水果
weixin_30323961的博客
04-01 159
题目链接：http://acm.hdu.edu.cn/showproblem.php?pid=1263 Problem Description 夏天来了~~好开心啊,呵呵,好多好多水果~~ Joe经营着一个不大的水果店.他认为生存之道就是经营最受顾客欢迎的水果.现在他想要一份水果销售情况的明细表,这样Joe就可以很容易掌握所有水果的销售情况了. Input 第一行正整数N(0&l...
机器学习面试要点总结
飘过的春风
03-19 1230
1、说到xgboost，不得不说gbdt。gbdt详细说明见下面这篇文章。   https://www.cnblogs.com/ModifyRong/p/7744987.html   2、逻辑回归面试经常问的问题   http://www.cnblogs.com/ModifyRong/p/7739955.html   3、如何快速的构建用户画像  http://www.cnblogs...
机器学习&数据挖掘笔记_16（常见面试之机器学习算法思想简单梳理）
weixin_34320724的博客
10-29 6019
  　　前言： 　　找工作时（IT行业），除了常见的软件开发以外，机器学习岗位也可以当作是一个选择，不少计算机方向的研究生都会接触这个，如果你的研究方向是机器学习/数据挖掘之类，且又对其非常感兴趣的话，可以考虑考虑该岗位，毕竟在机器智能没达到人类水平之前，机器学习可以作为一种重要手段，而随着科技的不断发展，相信这方面的人才需求也会越来越大。 　　纵观IT行业的招聘岗位，机器学习之类的岗位还是...
一、JAVA编程基础---水果超市系统
学习笔记记录，欢迎批评指正！2023年4月1日起，将不在继续更新，后续笔记将同步至语雀笔记（https://www.yuque.com/javazhangjinhe）
06-14 1330
基础总结
Java设计一个苹果类Aple,Java设计模式-创建型模式(1)
weixin_31104245的博客
03-22 653
简单工厂模式简单工厂模式严格意义上来说，并不属于设计模式中的一种，不过这里还是简单记录下。定义：由一个工厂对象决定创建出哪一种类型实例。客户端只需传入工厂类的参数，无心关心创建过程。优点：具体产品从客户端代码中抽离出来，解耦。缺点：工厂类职责过重，增加新的类型时，得修改工程类得代码，违背开闭原则。举例：新建Fruit水果抽象类，包含eat抽象方法：public abstract class Fru...
机器学习算法GBDT的面试要点总结-上篇
weixin_30364325的博客
11-07 1058
1.简介 gbdt全称梯度提升决策树，在传统机器学习算法里面是对真实分布拟合的最好的几种算法之一，在前几年深度学习还没有大行其道之前，gbdt在各种竞赛是大放异彩。原因大概有几个，一是效果确实挺不错。二是即可以用于分类也可以用于回归。三是可以筛选特征。这三点实在是太吸引人了，导致在面试的时候大家也非常喜欢问这个算法。gbdt的面试考核点，大致有下面几个: gbdt 的算法的流程？...
机器学习高频面试题之---简述GBDT与XGBoost的区别
jackmcgradylee的博客
09-01 1万+
最近校招面试被问到了这个问题，之前也在搜集了一些资料，在此整理一下，贴在这里。一、基本概念GBDT（又称Gradient Boosted Decision Tree/Grdient Boosted Regression Tree），是一种迭代的决策树算法，该算法由多个决策树组成。它最早见于yahoo，后被广泛应用在搜索排序、点击率预估上。xgboost是陈天奇大牛新开发的Boosting库。它是一个
PV操作解决吃水果问题（Java实现）
热门推荐
Bison的博客
10-26 1万+
【题目】：桌上有一只盘子，每次只能放入一个水果。爸爸专向盘子中放苹果，妈妈专向盘子中放桔子，一个女儿专等吃盘子里的苹果，一个儿子专等吃盘子里的桔子。只要盘子空则爸爸或妈妈都可以向盘子放一个水果，仅当盘子中有自己需要的水果时，儿子或女儿可以从盘子中取出水果分析： 桌子上只有一个盘子且只能装一个水果，而父亲和母亲都能向盘子中放水果，所以父亲和母亲是互斥关系，同一时间只能一个人往盘子放水果。 儿子和女儿从
java 创建水果_java 方法
weixin_34610364的博客
02-13 452
方法的定义一般情况下，定义一个方法包含以下语法：修饰符 返回值类型 方法名(参数类型 参数名){... 方法体 ... return返回值; }方法包含一个方法头和一个方法体。下面是一个方法的所有部分：修饰符：修饰符，这是可选的，告诉编译器如何调用该方法。定义了该方法的访问类型。返回值类型 ：方法可能会返回值。returnValueType 是方法返回值的数据类型。有些方法执行所需的操作，但没有返...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值