2022-08-03 第五组 张明敏 学习笔记

最新推荐文章于 2024-07-12 14:17:28 发布
最新推荐文章于 2024-07-12 14:17:28 发布
阅读量94 收藏
点赞数
分类专栏： Java 多线程 文章标签： 学习 java jvm
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_50392643/article/details/126143058
版权

目录

一、锁

1. synchronized处理多线程并发编程。

2.  synchronized有三种方式来加锁，分别是： 

3.死锁

4. 线程重入

5. Object类对多线程的支持

6. 方法总结：

7. 线程的退出

8. 中断线程

9. 线程的常用方法：

10.懒汉式：过时        内部类，枚举

二、小案例

 方法一：

方法二：

三、心得体会

 一、锁

1. synchronized处理多线程并发编程。

  重量级锁。1.6对synchronized进行了优化。

   1.6为了减少获得锁和释放锁带来的性能消耗引入的偏向锁和轻量级锁


2.  synchronized有三种方式来加锁，分别是：

  1.修饰实例方式，作用于当前实例加锁，进入同步代码前要获得当前实例的锁
   2.静态方法，作用于对当前类对象加锁，进入同步代码前要获得当前类对象的锁
   3.代码块，指定加锁对象，给指定的对象加锁，进入同步代码块之前要获得给定对象的锁
   

    1.实例方法：调用该方法的实例
    2.静态方法：类对象
    3.this：调用该方法的实例对象
    4.类对象：类对象
    操作共享数据的代码
    共享数据：多个线程共同操作的变量，可以充当锁

 public static void main(String[] args) {
        //同步代码快
        //创建一个对象
        //类对象
        //当前实例this
        //同步监视器
        synchronized (Ch01.class){
            int a = 1;
        }
    }

当时用同步方法，synchronized所著的东西是this（默认的）

类同步方法：
1.同步方法依然涉及到同步锁对象，不需要我们写出来
2.非静态的同步方法，同步锁就是this
  静态的同步方法，同步监视器就是类本身

同步代码快：
1.选好同步监视器（锁）推荐使用类对象，第三方对象，this
2.在实现接口创建的线程类中，同步代码快不可以用this来充当同步锁

同步的方式，解决线程安全问题。
操作同步代码时，只有一个线程能参与，其他的线程等待
相当于一个单线程的过程，效率低。

synchronized只针对当前JVM可以解决线程安全问题
synchronized不可以跨JVM解决问题！！！

public class Window implements Runnable {
    private String name;
    private static int ticket = 10;

    private static Object object = new Object();

    public Window(String name) {
        this.name = name;
    }

    @Override
    public void run() {
        synchronized (Window.class) {//(Object)或者是类对象*推荐
            while (true) {
                if (ticket > 0) {
                    try {
                        Thread.sleep(100);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                    System.out.println(name + "窗口，剩余" + ticket-- + "张");
                } else {
                    break;
                }
            }
        }
    }
}
class Ch02{
    public static void main(String[] args) {
        Thread t1=new Thread(new Window("1"));
        Thread t2=new Thread(new Window("2"));
        t1.start();
        t2.start();
    }
}

 

3.死锁

死锁是这样一个情形：多线程同时被阻塞，他们中的一个或者全部
都在等待某个资源的释放，由于线程无限期的阻塞，程序就不可能正常终止

死锁产生四个必要条件：
1.互斥使用，当资源被一个线程使用（占用），别的线程不能使用
2.不可抢占，资源请求者不能强制从占有者中抢夺资源，资源只能从占有者手动释放
3.请求和保持
4.循环等待，存在一个等待队列。P1占有P2资源，P2占有P3资源，P3占有P1资源
       形成了一个等待环路

class LockA implements Runnable{

    @Override
    public void run() {
        System.out.println(new Date().toString()+"LockA开始执行");
        while (true){
            synchronized (Ch03.obj1){
                System.out.println(new Date().toString()+"LockA锁住了obj1");
                try {
                    Thread.sleep(1000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }

            }

            synchronized (Ch03.obj2){
                System.out.println(new Date().toString()+"LockA锁住了obj2");
                try {
                    Thread.sleep(6000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        }

    }
}

class LockB implements Runnable{

    @Override
    public void run() {
        System.out.println(new Date().toString()+"LockB开始执行");
        while (true){
            synchronized (Ch03.obj1){
                System.out.println(new Date().toString()+"LockB锁住了obj1");
                try {
                    Thread.sleep(6*1000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }

            }

            synchronized (Ch03.obj2){
                System.out.println(new Date().toString()+"LockB锁住了obj2");
                try {
                    Thread.sleep(3000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        }

    }
}

public class Ch03 {
    public static String obj1="obj1";
    public static String obj2="obj2";

    public static void main(String[] args) {
        LockA lockA=new LockA();
        new Thread(lockA).start();

        LockB lockB=new LockB();
        new Thread(lockB).start();
    }

 

4. 线程重入

任意的线程在拿到锁之后，再次获取该锁不会被该锁阻碍

线程不会被自己锁死
这就叫线程重入，synchronized可重入锁

JDK1.6升级锁
1.无锁：不加锁
2.偏向锁：不锁锁，只有一个线程争夺时，偏向某一个线程，这个线程不加锁
3.轻量级锁：少量线程来了之后，想尝试自旋，不挂起线程。
4.重量级锁：排队挂起线程。（synchronized）

挂起线程和恢复线程需要转入内核态中完成这些操作，给系统的并发性带来很大的压力。
在许多应用上共享数据的锁定状态，只会持续很短的时间，为了这段时间去挂起和恢复并不值得
我们可以让后面的线程等待一下，不要放弃处理器的执行时间。
锁为了让线程等待，我们只需要让线程执行一个循环，自旋。【自旋锁】

hashcode 值 1 0

private static final Object M1=new Object();
    private static final Object M2=new Object();

    public static void main(String[] args) {
        new Thread(()->{
            synchronized (M1){
                synchronized (M2){
                    synchronized (M1){
                        synchronized (M2){
                            System.out.println("hello lock");
                        }
                    }
                }
            }
        }).start();

    }

 

5. Object类对多线程的支持

wait（）：
wait（long timeout）：当前线程进入等待状态
notify（）：唤醒正在等待的下一个线程
notifyAll（）：唤醒正在等待的所有线程

*线程间的通信
*比如两条线程，共同运行。
*线程A如果先走，线程就要等待。等待线程A走完，唤醒线程B，线程B再走

 private static int num = 10;
    private static final Object OBJ = new Object();

    public static void plus(int code, int i) {
        synchronized (OBJ) {
            if (num >= 10) {
                //唤醒其他等待的线程
                OBJ.notify();
                //唤醒所有线程
//                OBJ.notifyAll();
            }
            System.out.println("这是线程" + code + "->" + ++num + "->" + i);
        }
    }

    public static void sub(int code, int i) {
        synchronized (OBJ) {
            if (num <= 0) {
                try {
                    OBJ.wait(1000);//等待
                } catch (InterruptedException e) {
                    throw new RuntimeException(e);
                }
            }
            System.out.println("这是线程" + code + "->" + --num + "->" + i);

        }
    }

    public static void main(String[] args) {
        Thread t1 = new Thread(() -> {
            for (int i = 0; ; i++) {
                try {
                    Thread.sleep(5);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                sub(1, i);
            }
        });

        Thread t2 = new Thread(() -> {
            for (int i = 0; ; i++) {
                try {
                    Thread.sleep(10);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                plus(2, i);
            }
        });
        t1.start();
        t2.start();
    }

 

6. 方法总结：

1.Thread的两个静态方法：
    sleep释放CPU资源，但是不会释放锁
    yield方法释放CPU的执行权，保留CPU的执行资格，不常用

2.join方法，yield出让了执行权，join就加入了进来
3.wait：释放CPU资源，释放锁
    notify：唤醒等待线程
    notifyAll：唤醒等待的所有线程

  面试题：sleep和wait的区别？
  1.出处：sleep来自于Thread类，wait来自Object类
  2.锁的控制： sleep释放CPU资源，但是不会释放锁；wait：释放CPU资源，释放锁

 

7. 线程的退出

使用退出标志，线程正常退出，run方法结束后线程终止

class MyThread extends Thread{
    boolean flag=true;
    @Override
    public void run() {
        while (flag){
            try {
                System.out.println("线程一直运行");
                int i=10/0;
            }catch (Exception e){
                System.out.println("线程停止运行");
                this.stopThread();
            }
        }

    }

    private void stopThread() {
        System.out.println("线程一直运行");
        this.flag=false;
    }
}



public class Ch03 {
    public static void main(String[] args) {
        MyThread myThread=new MyThread();
        myThread.start();
    }
}

8. 中断线程

interrupt方法

调用interrupt方法会抛出InterruptedException异常，
捕获后再做停止线程的逻辑即可。
如果线程while(true)运行的状态，interrupt方法无法中断线程

class MyThread2 extends Thread{
    volatile boolean flag;
    public void run(){
        while (flag){
            synchronized (this){
                try {
                    sleep(10);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                    this.stopThread();
                }
            }
        }
    }

    private void stopThread() {
        System.out.println("");
        this.flag=false;
    }

}

public class Ch04 {

    public static void main(String[] args) {
            MyThread2 myThread2 = new MyThread2();myThread2.start();
            System.out.println("线程开始...");
            try {
                Thread.sleep(500);
            } catch (InterruptedException e){
                e.printStackTrace();
            }
            //中断线程的执行
            myThread2.interrupt();
        }
    }

 

9. 线程的常用方法：

Thread类中的方法
1.start：启动线程，执行run方法
2.run：
3.currentThread：静态方法，获取当前正在执行的线程
4.getID()：返回此线程的唯一标识
5.setName(String)：设置当前线程name
6.getName()：设置当前线程name
7.getPriority()：获取当前线程的优先级
8.setPriority()：设置当前线程的优先级
9.getState()：中断线程执行
10.interrupt()：测试当前线程是否中断
11.isDaemon()；测试当前线程是否是守护线程

10.懒汉式：过时        内部类，枚举

class Singleton{
    private static Singleton instant;
    private Singleton(){}

    public static  Singleton getInstance() {
            if (instant == null) {
                //卡了
                synchronized (Singleton.class) {
                    if (instant == null) {
                        instant = new Singleton();
                    }
                }
            }
            return instant;
        }
    }

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


    }
}



二、小案例

生产者消费者案例中包含的类：
奶箱类(Box)：定义一个成员变量，表示第x瓶奶，提供存储牛奶和获取牛奶的操作
生产者方法(Producer)：synchronized void put(int milk)
//消费者方法
synchronized void get(){
测试类(BoxDemo)：里面有main方法，main方法中的代码步骤如下（采用箭头函数）
1.创建2个线程对象，生产者对象和消费者对象
启动线程

 方法一：

public class Box {
     int x;
     static boolean flag=false;


    synchronized void put(int milk){
         if (flag==true){
             try {
                 wait();
             } catch (InterruptedException e) {
                 e.printStackTrace();
             }
         }
         this.x=milk;
        System.out.println(Thread.currentThread().getName()+"---生产"+x);
         flag=true;
         notify();
     }

     synchronized void get(int i){
         if (!flag){
             try {
                 wait();
             } catch (InterruptedException e) {
                 e.printStackTrace();
             }
         }
         System.out.println(Thread.currentThread().getName()+"---消费"+x);
         flag = false;
         notify();
     }

}

class BoxDemo{
    public static void main(String[] args) {
        Box box=new Box();
        new Thread(new Runnable() {
            @Override
            public void run() {
                for (int i = 1; i <=10 ; i++) {
                    box.put(i);
                }
            }
        },"生产者").start();

        new Thread(new Runnable() {
            @Override
            public void run() {
                for (int i = 1; i <=10 ; i++) {
                    box.get(i);
                }
            }
        },"消费者").start();

    }
}

 

方法二：

public class MilkBox {
    boolean flag=false;
    public synchronized void put(){
        if (flag==true){
            try {
                wait();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
        System.out.println("开始生产牛奶");
        System.out.println("生产完成");
        flag=true;
        notify();
    }

    public synchronized void get(){
        if (!flag){
            try {
                wait();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
        System.out.println("正在喝牛奶");
        System.out.println("牛奶喝完了");
        System.out.println("-----------");
        flag=false;
        notify();
    }
}

class MilkDemo{
    public static void main(String[] args) {
        MilkBox milkBox=new MilkBox();
        new Thread(new Runnable() {
            @Override
            public void run() {
                while (true){
                    try {
                        Thread.sleep(1000);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                    milkBox.put();
                }
            }
        },"生产者").start();

        new Thread(new Runnable() {
            @Override
            public void run() {
                while (true){
                    try {
                        Thread.sleep(1000);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                    milkBox.get();
                }
            }
        },"消费者").start();
    }
}

 

三、心得体会

被线程折磨的一天，锁懵了！

小张同学的小张
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
2022-08-05 第五组 张明敏 学习笔记
qq_50392643的博客
08-06 175
1.根节点是唯一的，不能存在多个根节点2.子树的个数没有限制，但他们一定是互不相交的。
2022-08-08 第五组 张明敏 学习笔记
qq_50392643的博客
08-08 123
JUnit是一个java语言单元测试框架。
2022-08-12 第五组 张明敏 学习笔记
qq_50392643的博客
08-12 98
构造匹配.任何字符（与行结束符可能匹配也可能不匹配）\d数字：[0-9]\D非数字： [^0-9]\s空白字符：[ \t\n\x0B\f\r]\S非空白字符：[^\s]\w单词字符：[a-zA-Z_0-9]\W非单词字符：[^\w]
2022-08-30 第五组 张明敏 学习笔记
qq_50392643的博客
09-16 181
这里处理逻辑时间应该是控制器的功能，但是我们并没有专门写一个控制器来做这件事情而是接受了VS的默认处理方式，将它写在Form的代码中，而这里的Form在MVC中它就是一个View。2、 如果Presenter过多地渲染了视图，往往会使得它与特定的视图的联系过于紧密，一旦视图需要变更，那么 Presenter也需要变更，Presenter的复用性不强。2、它用更新过的数据去更新模型（在被动MVC中控制器只是通知视图去更新过的模型中去取新的数据，而主动MVC中模型通知视图去更新显示，控制器不需要做工作）。
KFNet：KFNet：使用卡尔曼滤波学习时间相机的重新定位（CVPR 2020口头）
02-04
知识网这是我们的CVPR 2020口头论文的Tensorflow实施- ，沉天伟，张家辉，张明敏，姚瑶，田芳，龙权的 。 本文通过将场景坐标回归问题折叠到原理性的卡尔曼滤波器框架中，解决了时序图像数据的时间摄像机重新定位...
虚拟服装中人体拓扑无关的试穿技术研究
04-02
《虚拟服装中人体拓扑无关的试穿技术研究》这篇论文探讨了在3D试衣领域的一项重要技术，即如何高效地将设计好的三维服装模型适配到不同体型和拓扑结构的人体模型上。传统的计算机辅助设计(CAD)系统在创建三维服装时...
2021高考英语二轮复习小综合训练3含解析202102232193
08-07
内容中提到，今年的春晚吸引了超过6.214亿国内观众和2480万海外观众通过电视观看，同时有5.27亿观众通过新媒体平台如应用程序、网站、视频流媒体和社交媒体进行收看。这显示出随着科技的发展，春晚的观看方式也日益...
爬虫学习日记
最新发布
wuhu_czy的博客
07-12 305
爬虫python code
Autoware.universe 高效学习第三章 -- 智驾技术务虚会之智驾技术栈讨论 其一
cy1641395022的博客
07-10 659
Autoware.universe 高效学习第三章 -- 智驾技术务虚会之智驾技术栈讨论 其一
“Numpy数据分析与挖掘：高效学习重点技能“
光就是羁绊之力，它会再度被某人继承，散发出耀眼的光。
07-10 945
在计算统计中，如果把nan的值替换为0进行统计，这样并不合适，替换之前的平均值如果大于0，替换之后均值肯定会变小；统计存在有nan的列，将nan的列中其它不等于nan的值进行mean求出均值，：小于15000的赋值为15000，大于等于50000的赋值为50000。：小于15000的赋值为0，大于等于15000的赋值为10。将统计除nan列的均值，再将均值赋值给当前列的nan值上；在数组运算中，不同的列，但是相同的行，是可以进行运算的；1.均匀分布：在相同的大小范围内的出现概率是等可能的；
ROS基础学习-ROS运行管理
周陽讀書
07-11 543
ROS运行管理。
jmeter-beanshell学习5-beanshell加减乘除运算
朱文宇的博客
07-08 294
jmeter使用beanshell，jmeter beanshell脚本编写，beanshell进行加减乘除运算
【安卓学习】文本切换器
m0_73241073的博客
07-08 634
文本切换器的使用
Python 学习中什么是异常处理，如何使用 try、except、finally ？
Itmastergo的博客
07-12 566
异常是程序执行过程中发生的非正常事件，这些事件会中断正常的程序指令流。当程序遇到错误时，Python 会抛出一个异常对象，异常对象包含了错误的类型和相关的信息。
Qt/QML学习-动画元素
QT、QML
07-12 430
Qt/QML学习-动画元素
NPDP含金量高吗？什么人适合学习NPDP？
PMP项目管理的博客
07-09 908
开始报名后先提交报名资料，通过审核后缴纳考试费用，即算报名成功；如果报名成功后被抽中审核了的话，则须提交相关资料进行资格审查，通过审查即可参加考试，未通过审核则会将考试费用退还给您；
论文学习_B2SFinder: Detecting Open-Source Software Reuse in COTS Software
kitsch0x97的博客
07-09 1184
随着结构设计模式的广泛采用以及缩短上市时间的迫切需要，越来越多的商业现成（COTS）软件产品正在开源软件（OSS）项目之上开发。如此快速的应用程序开发会导致一些不良问题，包括许可证违规和安全问题。在这些问题中，OSS 重用漏洞是最严重的问题之一。：当一些易受攻击的 OSS 代码集成到软件中并在该软件中重用时，OSS 漏洞可能会被引入到 COTS 软件中。此类 OSS 漏洞（称为OSS重用漏洞）普遍存在，会对 COTS 软件的安全产生严重影响。
昇思25天学习打卡营第19天|ShuffleNet图像分类
randomize0的专栏
07-12 697
在第15-18日的学习内容中，我们陆陆续续学习了计算机视觉相关的模型包括图像语义分割、图像分类、目标检测等内容，这些模型的运算往往都是在大算力设备上运行的，今天学习一种可以在移动设备上运行的图像分类模型-“ShuffleNet”。ShuffleNetV1是旷视科技提出的一种计算高效的CNN模型，和MobileNet, SqueezeNet等一样主要应用在移动端，所以模型的设计目标就是利用有限的计算资源来达到最好的模型精度。
AI学习环境 没有更好的替代 - （Google）Drive + Colab
jomoly的博客
07-09 897
但是随着一系列拉扯和2010退出大陆市场，drive的定位就非常尴尬了，容量吧够用，但是比起来国内市场的狗大户就完全不够看，最重要的网速和访问得不到保证，所以尬吹党不少，但体验就是如人饮水冷暖自知，要不然这块市场也轮不到微软的onedrive，onenote这些小字辈后来居上了。至于能运行，乃至开发，调教大模型的环境，呃，如果您在校，可以问问学校的数据中心，估计会拍的很满，毕竟是一个A100卖到20万，万卡集群，用电约等于一座城市这样量级的投入，折算下来，每分钟上千+刀。卧龙凤雏，一时瑜亮。

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值