JUC-多线程锁

最新推荐文章于 2022-10-20 14:30:34 发布
最新推荐文章于 2022-10-20 14:30:34 发布
阅读量165 收藏
点赞数
文章标签： java
原文链接：http://www.cnblogs.com/minmin123/p/11417447.html
版权

多线程锁的练习题

 1、标准访问，先打印短信还是邮件 

class  Phone {
    public    synchronized   void  sendSMS()  throws  Exception
    {
        Thread.sleep(400);题【2】添加延时
        System. out .println( "------sendSMS" );
    }

    public   synchronized   void  sendEmail()  throws  Exception
    {
        System. out .println( "------sendEmail" );
    }
    public void  getHello()
    {
        System. out .println( "------getHello" );
    }

}

 

public class MoreThreadLock {
    public   static   void  main(String[]  args )  throws  Exception
    {
        Phone  phone  =  new  Phone();
        Phone  phone2  =  new  Phone();
            new  Thread(() -> {
                try  {

                    phone .sendSMS();

                }  catch  (Exception  e ) {

                    e .printStackTrace();

                }

            },  "AA" ).start();



            Thread. sleep (100);



            new  Thread(() -> {

                try  {

                    phone .sendEmail();

                    //phone.getHello();

                    //phone2.sendEmail();

                }  catch  (Exception  e ) {

                    e .printStackTrace();

                }

            },  "BB" ).start();

        }
}

------sendSMS
------sendEmail

 

 2、停4秒在短信方法内，先打印短信还是邮件 

　　------sendSMS
　　------sendEmail

3、普通的hello方法，是先打短信还是hello ，

hello方法是普通方法，短信进程需要四秒

public class MoreThreadLock {
    public   static   void  main(String[]  args )  throws  Exception
    {
        Phone  phone  =  new  Phone();
        Phone  phone2  =  new  Phone();
            new  Thread(() -> {
                try  {

                    phone .sendSMS();

                }  catch  (Exception  e ) {

                    e .printStackTrace();

                }

            },  "AA" ).start();



            Thread. sleep (100);//主线程睡1秒，为了区分谁先执行



            new  Thread(() -> {

                try  {

                    phone.getHello();

                    //phone2.sendEmail();

                }  catch  (Exception  e ) {

                    e .printStackTrace();

                }

            },  "BB" ).start();

        }
}

 

4、现在有两部手机，先打印短信还是邮件

public class MoreThreadLock {
    public   static   void  main(String[]  args )  throws  Exception
    {
        Phone  phone  =  new  Phone();
        Phone  phone2  =  new  Phone();
            new  Thread(() -> {
                try  {

                    phone .sendSMS();


                }  catch  (Exception  e ) {

                    e .printStackTrace();

                }

            },  "AA" ).start();

            Thread. sleep (100);
new  Thread(() -> {

                try  {

                    phone2.sendEmail();

                }  catch  (Exception  e ) {

                    e .printStackTrace();

                }

            },  "BB" ).start();

        }
}

 

------sendEmail
------sendSMS

5、 两个静态同步方法，1部手机，先打印短信还是邮件 

class  Phone {
    public static   synchronized   void  sendSMS()  throws  Exception
    {
        Thread.sleep(400);题【2】添加延时
        System. out .println( "------sendSMS" );
    }

    public static  synchronized   void  sendEmail()  throws  Exception
    {
        System. out .println( "------sendEmail" );
    }
   
}

 

------sendSMS
------sendEmail

 6、两个静态同步方法，2部手机，先打印短信还是邮件 

public class MoreThreadLock {
    public   static   void  main(String[]  args )  throws  Exception
    {
        Phone  phone  =  new  Phone();
        Phone  phone2  =  new  Phone();
            new  Thread(() -> {
                try  {

                    phone .sendSMS();

                }  catch  (Exception  e ) {

                    e .printStackTrace();

                }

            },  "AA" ).start();



            Thread. sleep (100);//主线程睡1秒，为了区分谁先执行



            new  Thread(() -> {

                try  {

                    phone2.sendEmail();

                }  catch  (Exception  e ) {

                    e .printStackTrace();

                }

            },  "BB" ).start();

        }
}
4、现在有两部手机，先打印短信还是邮件

public class MoreThreadLock {
    public   static   void  main(String[]  args )  throws  Exception
    {
        Phone  phone  =  new  Phone();
        Phone  phone2  =  new  Phone();
            new  Thread(() -> {
                try  {

                    phone .sendSMS();


                }  catch  (Exception  e ) {

                    e .printStackTrace();

                }

            },  "AA" ).start();

            Thread. sleep (100);

            new  Thread(() -> {

                try  {

                    phone2.sendEmail();

                }  catch  (Exception  e ) {

                    e .printStackTrace();

                }

            },  "BB" ).start();

        }
}

 

 ------sendSMS
------sendEmail

7、1个静态同步方法，1个普通同步方法，1部手机，先打印短信还是邮件 

class  Phone {
    public static   synchronized   void  sendSMS()  throws  Exception
    {
        Thread.sleep(400);题【2】添加延时
        System. out .println( "------sendSMS" );
    }

    public   synchronized   void  sendEmail()  throws  Exception
    {
        System. out .println( "------sendEmail" );
    }
   
}

 

------sendEmail
------sendSMS

8、1个静态同步方法，1个普通同步方法，2部手机，先打印短信还是邮件 

class  Phone {
    public static   synchronized   void  sendSMS()  throws  Exception
    {
        Thread.sleep(400);题【2】添加延时
        System. out .println( "------sendSMS" );
    }

    public   synchronized   void  sendEmail()  throws  Exception
    {
        System. out .println( "------sendEmail" );
    }
   
}

 

------sendEmail
------sendSMS

总结：

A 一个对象里面如果有多个synchronized方法，某一个时刻内，只要一个线程去调用其中的一个synchronized方法了， 

其它的线程都只能等待，换句话说，某一个时刻内，只能有唯一一个线程去访问这些synchronized方法 

锁的是当前对象this，被锁定后，其它的线程都不能进入到当前对象的其它的synchronized方法 

加个普通方法后发现和同步锁无关 

换成两个对象后，不是同一把锁了，情况立刻变化。 

  

synchronized实现同步的基础：Java中的每一个对象都可以作为锁。 

具体表现为以下3种形式。 

对于普通同步方法，锁是当前实例对象。 

对于静态同步方法，锁是当前类的Class对象。 

对于同步方法块，锁是 Synchonized 括号里配置的对象 

  

当一个线程试图访问同步代码块时，它首先必须得到锁，退出或抛出异常时必须释放锁。 

  

也就是说如果一个实例对象的非静态同步方法获取锁后，该实例对象的其他非静态同步方法必须等待获取锁的方法释放锁后才能获取锁， 

可是别的实例对象的非静态同步方法因为跟该实例对象的非静态同步方法用的是不同的锁， 

所以毋须等待该实例对象已获取锁的非静态同步方法释放锁就可以获取他们自己的锁。 

  

所有的静态同步方法用的也是同一把锁——类对象本身， 

这两把锁是两个不同的对象，所以静态同步方法与非静态同步方法之间是不会有竞态条件的。 

但是一旦一个静态同步方法获取锁后，其他的静态同步方法都必须等待该方法释放锁后才能获取锁， 

而不管是同一个实例对象的静态同步方法之间， 

还是不同的实例对象的静态同步方法之间，只要它们同一个类的实例对象！

 

转载于:https://www.cnblogs.com/minmin123/p/11417447.html

weixin_30922589
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
c语言线程锁的作用,C语言创建线程以及使用锁进行读写分离
weixin_36162235的博客
05-18 1426
线程的使用1.线程的创建线程的相关操作放在中。1.1我们定义一个线程，首先要进行定义一个函数，类似我们创建一个a线程void *thread_a(void *in){printf("Im thread_a\n");pthread_exit((void*)0);}1.2.创建一个线程pthread_t a;//声明pthread_create(&a,NULL,thread_a,(void*)...
JUC 多线程
m0_46499246的博客
03-30 230
JUC 多线程介绍 1、 线程的生命周期 新建状态（New）：当线程对象对创建后，即进入了新建状态，如：Thread t = new MyThread(); 就绪状态（Runnable）：当调用线程对象的start()方法（t.start();），线程即进入就绪状态。处于就绪状态的线程，只是说明此线程已经做好了准备，随时等待CPU调度执行，并不是说执行了t.start()此线程立即就会执行； 运行状态（Running）：当CPU开始调度处于就绪状态的线程时，此时线程才得以真正执行，即进入到运行状
多线程(常见的锁策略)
m0_60631323的博客
08-25 583
常见锁
一文搞懂多线程中的死锁问题和解决思路
saha__的博客
06-10 837
死锁是指两个或两个以上的进程在执⾏过程中，由于竞争资源或者由于彼此通信⽽造成的⼀种阻塞的现象，若⽆外⼒作⽤，它们都将⽆法推进下去。形成死锁主要由以下 4 个因素造成的： 以下这四个条件缺一不可 ① 互斥条件 ⼀个资源只能被⼀个线程占有，当这个资源被占⽤之后其他线程就只能等待。 ② 不可被剥夺条件 当⼀个线程不主动释放资源时，此资源⼀直被拥有线程占有，其它线程就得不到此资源。 ③ 请求并持有条件 线程已经拥有了⼀个资源之后，有尝试请求新的资源。④ 环路等待条件 产⽣死锁⼀定是发⽣了线程资源环形链。利用死锁的产
linux C语言 多线程竞争（加锁解锁 pthread_mutex_t、pthread_mutex_lock()、pthread_mutex_unlock() 可解决）
Dontla的博客
07-25 1526
线程在短时间内对相同内存单元进行操作时，如果不加锁解锁，有可能产生线程竞争的情况，即最终结果不符合预期。
windows 多线程编程的几点经验 (防止死锁)
Tinna_zhang的专栏
08-05 318
windows 多线程编程的几点经验 (防止死锁) 作者： smilestone322 (1 篇文章) 日期： 八月 3, 2011 在 5:48 下午   1) 不要在线程函数体内操作MFC控件，不要再线程里面调用UpdateData函数更新用户界面，而应该尽量采用发
Java-JUC-多线程 进阶
07-05
Java-JUC-多线程进阶resources是 Java 并发编程的高级课程，涵盖了 Java 中的并发编程概念、线程安全、锁机制、集合类、线程池、函数式接口、Stream流式计算等多个方面。 什么是JUC JUC（Java Utilities for ...
JUC多线程学习个人笔记
07-08
Java Util Concurrent（JUC）是Java并发编程的核心库，提供了丰富的工具和接口，使得开发者能够高效、安全地处理多线程环境中的并发问题。以下将详细介绍JUC中的关键概念和特性。 1. **线程池**：JUC通过Executor...
人工智能-项目实践-多线程-多线程与高并发.zip
01-04
此外，同步机制是多线程编程中的关键，包括互斥锁（synchronized关键字）、读写锁（ReentrantReadWriteLock）、条件变量（Condition）等，它们确保了共享数据在多线程环境下的安全性。避免死锁和活锁也是多线程编程...
heima-JUC-资料
最新发布
04-25
Java并发编程是Java Util Concurrency（JUC）库的核心内容，它为多线程环境提供了高效、安全且灵活的工具和API。JUC是Java 5及后续版本引入的一个重要特性，极大地提升了Java在多处理器和高并发环境下的性能表现。 ...
JUC-master
03-21
在Java世界中，JUC（Java Util Concurrency）是并发编程的核心库，它提供了丰富的并发工具类，帮助开发者有效地处理多线程和高并发场景。JUC库是Java 5引入的一个重大改进，大大简化了并发编程的复杂性，提高了程序...
C++多线程(3)-死锁
qq_27577503的博客
08-28 116
认识死锁 我自己在实际中碰到的死锁比较少，因为大多数时候，并没有用到2个以上的锁。先来看看死锁吧，主要是多个进程之间对资源进行竞争导致的一种僵持状态。线程就是精华版的进程了。 死锁产生的四个条件 自己在不经意之间产生的死锁，其实也是有着一些总结的规律： 1，互斥资源：进程要求分配的资源进行排他性控制，即在一段时间内某资源仅为一进程所占用；（这里就相当于对资源加上互斥锁） 2，资源不可强占：进程已获得的资源在未使用完之前，不能剥夺，只能在使用完时由自己释放；（这里相当于线程1无法打开线程2的锁） 3，占有且等
多线程（1）：互斥锁
qq_39385537的博客
10-20 184
多线程
多线程8锁案例演示
KEELON的博客
08-31 283
比如代码中A线程持有A锁，希望获得B锁，B锁又被B线程持有，B锁又希望或者A，他们都获得不得想要的锁，只能等待了。非公平锁是，是指的多个线程获取锁的顺序并不是按照申请锁的顺序，有个后申请锁的顺序的线程优先或许锁。在方法上加的锁，都是对象锁，一旦一个线程进入某个被锁的方法，其他线程也不能进入其他枷锁的方法。公平锁 是指多个线程按照申请锁的顺序来获取锁。可冲入锁，又名递归锁。wait进入等待是时候，释放所持有的锁，等待其他线程notify唤醒。类锁锁的事整个类，即该类new出来的其他对象都是持有相同的锁。...
Java多线程——线程八锁案例分析
qq_15138049的博客
06-13 173
摘要：本文主要学习了多线程并发中的一些案例。 部分内容来自以下博客： https://blog.csdn.net/dyt443733328/article/details/80019352 多线程的八个案例 通过分析代码，推测打印结果，并运行代码进行验证。 1）两个线程调用同一个对象的两个同步方法 代码如下： 1 public class Demo { 2 public static void main(String[] args) { 3 Number ...
【多线程】多线程及锁常见问题集合
numbbe的博客
02-12 978
问题集合多线程常见问题之多线程安全问题多线程常见问题之多线程乱跑传参问题 多线程常见问题之多线程安全问题 明确一点，不操作共享变量就不会有线程安全问题。 有线程安全问题，什么时候加锁 共享数据有可能同时被两个线程操作，再加锁。 不能碰到多线程就想到线程安全，然后加锁。 锁的前提是你操作了共享变量，如果没有共享变量，是不存在数据安全问题的，并且不能盲目的追求速度快，忽视了数据的安全，本末倒置。 乱用锁的后果是性能降低或者死锁。 效率和数据安全是个跷跷板，A高了，B就低，合理的运用锁，才是正解。 多线程常见问题
多线程 加锁
Sarah_212的博客
09-24 3811
线程同步 对多线程来说，资源是共享的，基本上不存在不允许访问的情况，但是，共享的资源在某一时间点只能有一个线程占用，所以需要给资源加锁。 线程的锁的种类 互斥锁 读写锁 条件变量 自旋锁 信号灯 互斥锁 互斥锁机制是同一时刻只允许一个线程占有共享的资源。 初始化锁 intpthread_mutex_init(pthread_mutex_t*mutex,constpthread_mutex_attr_t*mutexattr); 参数 mutexattr 用于指定锁的属性（见下）...
Java并发编程-八锁问题带你彻底理解对象锁和类锁
Java硬件工程师的博客
01-15 2163
8锁问题演示 1.标准访问 标准访问，先打印邮件还是短信. 不一定谁先被打印。取决于CPU的执行情况.激活他们的是main线程，后面谁先被调度，不知道。 为了保证效果，我们在A和B的代码之间加thread.sleep(100).此时，可以确保A先被打印。 解释： 进入到main方法中之后，就是A找邮件，B找短信的方法。加完锁之后，同时进来，各回各家，各找各妈。因为我们人为的在A和B之间加了休眠时间，那么A肯定发生在B之前。按照标准访问。此时先打印邮件 /*手机类可以发邮件和发短信*/ class Phone
线程死锁问题
最自由的笑的博客
08-17 340
多把锁 为了提高并发度我们可以提供多把锁，假设有一个共享资源room对象，很多线程会去访问，一部分线程只访问其中a资源，另一部分线程只访问b的资源，此时如果所有线程把锁加在room对象上面虽然可以保证线程安全，但是并发度不高。 class Room{ Object a= new Object(); Object b= new Object(); } 此时可以使用两把锁，不要把锁加在room对象，而是分别加在a和b对象，这样第一类线程只需要申请a的锁，第二类线程只需要申请b的锁，锁的粒

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值