线程八锁以及代码实现

最新推荐文章于 2024-01-22 14:18:47 发布
最新推荐文章于 2024-01-22 14:18:47 发布
阅读量178 收藏
点赞数
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/tian1191132442/article/details/104429120
版权

题目：判断打印的 “one” or “two” ？

    1. 两个普通同步方法，两个线程，标准打印， 打印? //one two
    1. 新增 Thread.sleep() 给 getOne() ,打印? //one two
    1. 新增普通方法 getThree() , 打印? //three one two
    1. 两个普通同步方法，两个 Number 对象，打印? //two one
    1. 修改 getOne() 为静态同步方法，打印? //two one
    1. 修改两个方法均为静态同步方法，一个 Number 对象? //one two
    1. 一个静态同步方法，一个非静态同步方法，两个 Number 对象? //two one
    1. 两个静态同步方法，两个 Number 对象? //one two

// 1. 两个普通同步方法，两个线程，标准打印， 打印? //one two
// 2. 新增 Thread.sleep() 给 getOne() ,打印? //one two


public class One {
    public static void main(String[] args) {
        Demo demo=new Demo();
        new Thread(new Runnable() {
            @Override
            public void run() {
                demo.getOne();
            }
        }).start();
        new Thread(new Runnable() {
            @Override
            public void run() {
                demo.getTwo();
            }
        }).start();
    }

}
class Demo{
    public synchronized void getOne(){
        try {
            Thread.sleep(3000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println("one");
    }
    public synchronized void getTwo(){
        System.out.println("two");
    }
}

1、2：同步方法的所对象是this，先调用的方法先执行，虽然是两个线程，但是只能有一个同步方法被执行。

// 3. 新增普通方法 getThree() , 打印? //three one two

public class One {
    public static void main(String[] args) {
        Demo demo=new Demo();
        new Thread(new Runnable() {
            @Override
            public void run() {
                demo.getOne();
            }
        }).start();
        new Thread(new Runnable() {
            @Override
            public void run() {
                demo.getTwo();
            }
        }).start();
        new Thread(new Runnable() {
            @Override
            public void run() {
                demo.getThree();
            }
        }).start();
    }

}
class Demo{
    public synchronized void getOne(){
        try {
            Thread.sleep(3000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println("one");
    }
    public synchronized void getTwo(){
        System.out.println("two");
    }
    public void getThree(){
        System.out.println("Three");
    }
}

3.同步方法不受锁的约束

 // 4. 两个普通同步方法，两个 Number 对象，打印?  //two  one
public class One {
    public static void main(String[] args) {
        Demo demo=new Demo();
        Demo demo1=new Demo();
        new Thread(new Runnable() {
            @Override
            public void run() {
                demo.getOne();
            }
        }).start();
        new Thread(new Runnable() {
            @Override
            public void run() {
                demo1.getTwo();
            }

       }).start();
         /*new Thread(new Runnable() {
            @Override
            public void run() {
                demo.getThree();
            }
        }).start();*/

    }

}
class Demo{
    public synchronized void getOne(){
        try {
            Thread.sleep(3000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println("one");
    }
    public synchronized void getTwo(){
        System.out.println("two");
    }
  /*  public void getThree(){
        System.out.println("Three");
    }*/
}

4.形成线程同步的前提是，多个线程拥有同一把锁，本题创建了两个对象，相当于两把锁了。故：各自执行各自的

//5. 修改 getOne() 为静态同步方法，打印?  //two   one
public class One {
    public static void main(String[] args) {
        Demo demo=new Demo();
        new Thread(new Runnable() {
            @Override
            public void run() {
                demo.getOne();
            }
        }).start();
        new Thread(new Runnable() {
            @Override
            public void run() {
                demo.getTwo();
            }

       }).start();
         /*new Thread(new Runnable() {
            @Override
            public void run() {
                demo.getThree();
            }
        }).start();*/

    }

}
class Demo{
    public synchronized static void getOne(){
        try {
            Thread.sleep(3000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println("one");
    }
    public synchronized void getTwo(){
        System.out.println("two");
    }
  /*  public void getThree(){
        System.out.println("Three");
    }*/
}

5.静态的同步方法的锁是类实例，同步方法的锁是this，两个线程拥有不同的锁，所以实现不了同步

// * 6. 修改两个方法均为静态同步方法，一个 Number 对象?  //one   two
public class One {
    public static void main(String[] args) {
        Demo demo=new Demo();
        new Thread(new Runnable() {
            @Override
            public void run() {
                demo.getOne();
            }
        }).start();
        new Thread(new Runnable() {
            @Override
            public void run() {
                demo.getTwo();
            }

       }).start();
         /*new Thread(new Runnable() {
            @Override
            public void run() {
                demo.getThree();
            }
        }).start();*/

    }

}
class Demo{
    public synchronized static void getOne(){
        try {
            Thread.sleep(3000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println("one");
    }
    public synchronized static void getTwo(){
        System.out.println("two");
    }
  /*  public void getThree(){
        System.out.println("Three");
    }*/
}

6.都是静态方法，公用一个对象锁（类实力），故可以实现同步

//* 7. 一个静态同步方法，一个非静态同步方法，两个 Number 对象?  //two  one
public class One {
    public static void main(String[] args) {
        Demo demo=new Demo();
        Demo demo1=new Demo();
        new Thread(new Runnable() {
            @Override
            public void run() {
                demo.getOne();
            }
        }).start();
        new Thread(new Runnable() {
            @Override
            public void run() {
                demo1.getTwo();
            }

       }).start();
         /*new Thread(new Runnable() {
            @Override
            public void run() {
                demo.getThree();
            }
        }).start();*/

    }

}
class Demo{
    public synchronized static void getOne(){
        try {
            Thread.sleep(3000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println("one");
    }
    public synchronized  void getTwo(){
        System.out.println("two");
    }
  /*  public void getThree(){
        System.out.println("Three");
    }*/
}

7.不是同一个锁，故不同步

// * 8. 两个静态同步方法，两个 Number 对象?   //one  two
public class One {
    public static void main(String[] args) {
        Demo demo=new Demo();
        Demo demo1=new Demo();
        new Thread(new Runnable() {
            @Override
            public void run() {
                demo.getOne();
            }
        }).start();
        new Thread(new Runnable() {
            @Override
            public void run() {
                demo1.getTwo();
            }

       }).start();
         /*new Thread(new Runnable() {
            @Override
            public void run() {
                demo.getThree();
            }
        }).start();*/

    }

}
class Demo{
    public synchronized static void getOne(){
        try {
            Thread.sleep(3000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println("one");
    }
    public synchronized static void getTwo(){
        System.out.println("two");
    }
  /*  public void getThree(){
        System.out.println("Three");
    }*/
}

8.静态同步方法的锁是“类实例”，与多少个对象无关

总结：通过上述的代码，可以得出：

在这里插入图片描述
在这里插入图片描述

tian1191132442
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
线程8锁（详细）
cookies___的博客
05-13 1335
线程8锁，超详细。 1.两个线程调用同一个对象的两个同步方法 结果是：one two 分析：第一个线程调用了getOne方法，获得了number对象的互斥锁，第二个线程等待第一个线程的getOne执行 完毕后，再执行getTow方法 2. 结果： 休眠1秒钟 后 one two 分析：线程1的Thread.sleep不释放互斥锁 3.新增一个线程调用新增的一个普通方法 结果是：three 休眠1秒 one two 分析：没有synchronized修饰的方法，线程调用时是和锁无关的 4.两个线程调用两个
Java 多线程 线程8锁（含示例代码）
weixin_55871070的博客
04-17 705
以下内容根据视频https://www.bilibili.com/video/BV1vE411D7KE?p=6学习整理 1.标准访问 class Phone{ public synchronized void sendEmail() throws Exception { System.out.println("**sendEmail"); } public synchronized void sendSMS() throws Exception { ...
【字节一面】线程八锁
激流丶的博客
07-04 513
线程八锁是指在多线程环境下，使用synchronized关键字对代码进行同步时，可能出现的八种不同的情况。 线程八锁。也是常见的面试题，**主要是针对锁对象的提问。**
线程八锁
The_Best_Hacker的博客
08-16 222
【问题一】 class Number{ public synchronized void a() { System.out.println(1); } public synchronized void b() { System.out.println(2); } } public static void main(String[]...
八卦锁的数量
qq_40934617的博客
01-26 776
题目描述： 陆伯言来到山顶观察此八卦阵，记从左往右第i堆石堆的高度为A[i]，发现任何两堆较矮的石堆都能和它们之间的一座较高的石堆形成"八卦锁"，将其中之人牢牢锁住，无从逃脱。根据石堆的情况，陆伯言大致计算了“八卦锁”的数量，陆伯言大致计算了“八卦锁”的数量（即 A[i] < A[j] > A[k] 且I < j < k的组合数），不禁心中一惊,对孔明惊为天人，遂放弃追击，收兵回吴。“有劳岳父了。” “为何将其放走？” “…一表人才，何必浪费于此。” 输入描述 第一行一个整数n，表.
Java编程实现排他锁代码详解
08-29
Java编程实现排他锁代码详解 在 Java 编程中，实现排他锁是一种常见的需求，特别是在多线程和多进程环境中。排他锁的目的是为了防止多个线程或进程同时访问同一个资源，从而避免数据不一致和其他问题。 在 Java 中...
vb.net C#线程锁超时控制代码
06-01
ManualResetEvent是一个超时等待的线程锁,如果超时返回false,接收指令显示true,但是没法实现在超时后让他继续等待,这种需求我们可以用在以下场景: 控制线程超时方法 1.[主线程]:请求方发送请求,立即创建超时等待...
java 多线程-锁详解及示例代码
09-01
本文主要讲解了Java中锁的基本概念、使用方式以及示例代码，旨在帮助开发者理解如何在多线程环境下实现线程安全。 首先，Java从5版本开始引入了`java.util.concurrent.locks`包，提供了更为灵活和强大的锁实现，...
java 线程锁详细介绍及实例代码
08-31
本文将深入探讨Java线程锁的使用、原理以及实例代码。 一、线程锁的概念与作用 线程锁，也称为互斥锁，主要用于控制多个线程对共享资源的访问，以避免并发执行时出现数据不一致的情况。当一个线程持有锁时，其他...
Python实现的多线程http压力测试代码
09-21
在Python中，多线程并不意味着真正的并行执行，因为Python的GIL（全局解释器锁）限制了同一时刻只有一个线程执行Python字节码。但是，多线程仍然可以在IO密集型任务（如网络请求）中发挥作用，因为在等待网络响应时...
C++实现线程锁
03-01
这是学习线程锁时候写的代码，用C++实现，很容易看懂
线程和线程锁的使用源码例子
01-13
线程和线程锁的使用源码例子
Java并发之线程八锁
fyphome
01-30 1682
一、引入 先了解什么是synchronized 不加 synchronzied 的方法就好比不遵守规则的人，不去老实排队（好比翻窗户进去的），记住一点，synchronized不是锁住了方法，而是锁住了使用了该方法的类对象或者对象实例，如： 1. 锁住对象实例： class Test{ public synchronized void test() { } } //等价于 class Test{ public void test() { synchronized(th
Java 线程八锁
最新发布
WaaTong的博客
01-22 380
关键字时的八种不同的锁现象，也被称为"著名的八个锁"。这主要是通过对静态方法、非静态方法、静态变量和非静态变量的组合使用。关键字来产生不同的效果。"线程八锁"通常是指在Java中使用。
八锁现象——synchronized关键字实战详解
欢迎。
05-24 1439
synchronized关键字到底锁的是谁？
并发编程学习之线程8锁
weixiaohuai的博客
02-26 752
一、简介 所谓线程八锁，其实就是就是线程锁的8种情况，对应于是否加上synchronized，是否加上static等8种常见情况，具体见下面详解。 二、线程8锁 第一种情况: 两个线程调用同一个对象的两个普通同步方法,先打印one还是two? /** * 线程八锁第一种情况: 两个线程调用同一个对象的两个普通同步方法,先打印one还是two? * <p> * 运行结果: ...
线程八锁问题超简单理解
weixin_45953000的博客
11-15 231
在并发的环境中，锁机制一个良好的控制同步的方法，使用synchronize关键字对临界资源的锁，在普通的成员方法中添加锁的是调用该方法的对象public synchronized void Sem(){//普通同步的发邮件的方法 System.out.println("发邮件"); }，而在静态方法中使用 则锁的整个类对象（类对象是在class加载的时候进行创建的，每一个类只用有一个）public static synchronized void Sem(){//普通同步的发邮件的方法 System.out
11.线程八锁
DevOps海洋的渔夫@专栏
03-01 375
11.线程八锁线程八锁•一个对象里面如果有多个synchronized方法，某一个时刻内，只要一个线程去调用其中的一个synchronized方法了，其它的线程都只能等待，换句话说，某一...
线程八锁详解
qq_43521756的博客
07-17 882
线程八锁得到的结论： 非静态方法的锁默认为 this, 静态方法的锁为 对应的 Class 实例 某一个时刻内，只能有一个线程持有锁，无论几个方法。 论证过程： 1、八锁案例：判断打印的 “one” or “two” 两个普通同步方法，两个线程，标准打印， 打印? //one two public class TestThread8Monitor { public static void main(String[] args) { Number number1 = new Numbe
多线程的并发的线程锁的C代码如何实现？
09-24
### 回答1： C语言中可以使用pthread库来实现多线程编程，其中pthread_mutex_t类型变量可以用来实现线程锁。 示例代码： ``` #include <pthread.h> pthread_mutex_t lock; void some_function() { pthread_mutex_lock(&lock); // critical section pthread_mutex_unlock(&lock); } int main() { pthread_mutex_init(&lock, NULL); // create and start threads pthread_mutex_destroy(&lock); return 0; } ``` 在程序开始时，使用pthread_mutex_init()函数初始化互斥锁。在需要保护的临界区域内调用pthread_mutex_lock()函数获得锁，在临界区域外调用pthread_mutex_unlock()释放锁。在程序结束时，使用pthread_mutex_destroy()销毁互斥锁。 需要注意的是，在获得锁后，如果另一个线程尝试获得相同的锁，它将会被阻塞直到锁被释放。 ### 回答2： 实现多线程的并发的线程锁的C代码通常使用互斥锁（Mutex）或者读写锁（ReadWrite Lock）来实现。 互斥锁的实现如下： ```c #include <stdio.h> #include <pthread.h> int count = 0; pthread_mutex_t lock; void* increment(void* arg) { pthread_mutex_lock(&lock); // 加锁 count++; pthread_mutex_unlock(&lock); // 解锁 return NULL; } int main() { pthread_t thread1, thread2; pthread_mutex_init(&lock, NULL); // 初始化互斥锁 pthread_create(&thread1, NULL, increment, NULL); pthread_create(&thread2, NULL, increment, NULL); pthread_join(thread1, NULL); pthread_join(thread2, NULL); pthread_mutex_destroy(&lock); // 销毁互斥锁 printf("Count: %d\n", count); // 输出结果 return 0; } ``` 读写锁的实现如下： ```c #include <stdio.h> #include <pthread.h> int count = 0; pthread_rwlock_t rwlock; void* read_func(void* arg) { pthread_rwlock_rdlock(&rwlock); // 读取加锁 printf("Read: %d\n", count); // 读取共享变量 pthread_rwlock_unlock(&rwlock); // 解锁 return NULL; } void* write_func(void* arg) { pthread_rwlock_wrlock(&rwlock); // 写入加锁 count++; // 修改共享变量 pthread_rwlock_unlock(&rwlock); // 解锁 return NULL; } int main() { pthread_t read_thread, write_thread; pthread_rwlock_init(&rwlock, NULL); // 初始化读写锁 pthread_create(&read_thread, NULL, read_func, NULL); pthread_create(&write_thread, NULL, write_func, NULL); pthread_join(read_thread, NULL); pthread_join(write_thread, NULL); pthread_rwlock_destroy(&rwlock); // 销毁读写锁 return 0; } ``` 以上代码分别使用互斥锁和读写锁来保证对共享变量的并发访问的线程安全。 ### 回答3： 多线程的并发中，为了保证线程间数据的一致性和安全性，需要使用线程锁。 在C语言中，可以使用互斥锁（mutex）来实现线程锁。以下是一个简单的使用互斥锁的多线程并发的C代码示例： 首先，需要引入头文件"pthread.h"，这是C语言中用于多线程编程的标准库。 ```c #include <pthread.h> #include <stdio.h> // 定义全局变量和互斥锁 int count = 0; pthread_mutex_t lock; // 线程函数 void* thread_func(void* arg) { // 加锁 pthread_mutex_lock(&lock); // 临界区操作 count++; printf("Thread ID: %ld, Count: %d\n", pthread_self(), count); // 解锁 pthread_mutex_unlock(&lock); // 线程退出 pthread_exit(NULL); } int main() { // 初始化互斥锁 pthread_mutex_init(&lock, NULL); // 创建多个线程 pthread_t tid1, tid2; pthread_create(&tid1, NULL, thread_func, NULL); pthread_create(&tid2, NULL, thread_func, NULL); // 等待线程结束 pthread_join(tid1, NULL); pthread_join(tid2, NULL); // 销毁互斥锁 pthread_mutex_destroy(&lock); return 0; } ``` 上述代码中，定义了一个全局变量`count`用于记录操作次数，并且定义了互斥锁`lock`。 线程函数`thread_func()`中，在临界区操作前先加锁，操作完成后解锁。这样就保证了同时只有一个线程能够进入临界区，保证了数据的一致性和安全性。 在`main()`函数中，首先初始化互斥锁，然后创建多个线程并等待线程结束。最后销毁互斥锁。 这样，通过互斥锁的加锁和解锁操作，实现了多线程的并发中线程锁的机制。

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值