java线程中的synchronized关键字和sleep()方法(案例)

最新推荐文章于 2024-06-03 17:23:39 发布
最新推荐文章于 2024-06-03 17:23:39 发布
阅读量1.4k 收藏 4
点赞数
文章标签： java 多线程 synchronized同步 sleep()方法 wait()
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/czh500/article/details/88930026
版权

java线程中的synchronized关键字和sleep()方法(案例)

直接po截图和代码

源码点这里

Service类

package com.demo.thread6;

/**
* 
* wait()、notify()、notifyAll()这3个函数，这3个函数都是Object类的方法
* sleep()是Thread类的方法
* 对于sleep()方法，我们首先要知道该方法是属于Thread类中的。而wait()方法，则是属
* 于Object类中的
* sleep()方法导致了线程暂停执行指定的时间，让出cpu给其他线程，但是他的监控状态依然保持者，当指
* 定的时间到了又会自动恢复运行状态
* 在调用sleep()方法的过程中，线程不会释放对象锁
* 而当调用wait()方法的时候，线程会放弃对象锁，进入等待此对象的等待锁定池，只有针对此对象调
* 用notify()方法后本线程才进入对象锁定池准备获取对象锁进入运行状态
* 
*/
public class Service {

	public synchronized void hello1() {
		System.out.println("我是同步方法hello1()");
		try {
			Thread.sleep(3000);
		} catch (InterruptedException e) {
			e.printStackTrace();
		}
		System.out.println("我是同步方法hello1()的结尾部分.......");
	}

	//运行结果有2种情况
	/**
	 * 情况1:
	 *运行结果，有可能是线程2先执行同步方法，执行完后，此时线程1再执行同步方法时，一直在wait,程
	 *序一直在wait，程序一直没结束 
	 */

	/**
	 * 情况2:
	 *运行结果，也有可能是线程1先执行同步方法，然后在执行过程中wait，然后此时释放锁，由线程2执行同步方法，在执
	 *行过程中调用了notifyAll()函数 ,然后唤醒了线程1，线程1继续执行后面的代码
	 * 
	 */
	//同步方法中使用wait()函数
	//wait()、notify()、notifyAll()这3个函数，这3个函数都是Object类的方法
	public synchronized void hello2(int temp) {
		System.out.println("我是同步方法hello2()");
		if (temp == 1) {
			System.out.println("你传的参数是" + temp + ",请等待.....");
			try {
				wait(); //有可能有这么一种情况，就是一直处于等待
				System.out.println("参数" + temp + "等待结束.....");
			} catch (InterruptedException e) {
				e.printStackTrace();
			}
		}else if (temp == 2){
			System.out.println("你传的参数是" + temp);
		}
		notifyAll();
		for (int i = 1; i <= 5; i++) {
			System.out.println("[参数：" + temp + "][次数：" + i + "]看看调用了notifyAll()函数后，是继续执行notifyAll()函数后面的代码，还是立刻接着执行wait()的后续代码");
		}
		System.out.println("我是同步方法hello2()的结尾部分.......,参数是" + temp);
	}
	
	//只有当一个线程执行完对象的同步方法之后，另一个线程才会执行同一个对象的同步方法
	//同步方法中使用sleep()函数
	//sleep()是Thread类的方法
	public synchronized void hi(int temp) {
		System.out.println("我是同步方法hi()");
		if (temp == 1) {
			System.out.println("你传的参数是" + temp + ",请等待.....");
			try {
				Thread.sleep(3000);
				System.out.println("参数" + temp + "等待结束.....");
			} catch (InterruptedException e) {
				e.printStackTrace();
			}
		}else if (temp == 2){
			System.out.println("你传的参数是" + temp);
		}
		System.out.println("我是同步方法hi()的结尾部分.......,参数是" + temp);
	}

	public void hello3() {
		System.out.println("我是普通方法hello3()");
	}
	
	public synchronized void hello4() {
		System.out.println("我是同步方法hello4()");
	}
	
	public void hello5() {
		System.out.println("我是同步方法hello5()");
		try {
			Thread.sleep(3000);
		} catch (InterruptedException e) {
			e.printStackTrace();
		}
		System.out.println("我是同步方法hello5()的结尾部分.......");
	}

}

A类

package com.demo.thread6;

public class A implements Runnable{

	Service service;
	
	public A(Service service) {
		this.service = service;
	}

	@Override
	public void run() {
		service.hello1();
	}

}

B类

package com.demo.thread6;

public class B implements Runnable{

	Service service;
	
	public B(Service service) {
		this.service = service;
	}

	@Override
	public void run() {
		service.hello4();
	}

}

C类

package com.demo.thread6;

public class C implements Runnable{

	Service service;
	
	public C(Service service) {
		this.service = service;
	}

	@Override
	public void run() {
		service.hello3();
	}

}

D类

package com.demo.thread6;

public class D implements Runnable{

	Service service;
	
	public D(Service service) {
		this.service = service;
	}

	@Override
	public void run() {
		service.hello5();
	}

}

E类

package com.demo.thread6;

public class E implements Runnable{

	Service service;
	
	public E(Service service) {
		this.service = service;
	}

	@Override
	public void run() {
		service.hello2(1);
	}

}

F类

package com.demo.thread6;

public class F implements Runnable{

	Service service;
	
	public F(Service service) {
		this.service = service;
	}

	@Override
	public void run() {
		service.hello2(2);
	}

}

G类

package com.demo.thread6;

public class G implements Runnable{

	Service service;
	
	public G(Service service) {
		this.service = service;
	}

	@Override
	public void run() {
		service.hi(1);
	}

}

H类

package com.demo.thread6;

public class H implements Runnable{

	Service service;
	
	public H(Service service) {
		this.service = service;
	}

	@Override
	public void run() {
		service.hi(2);
	}

}

Test类

package com.demo.thread6;

public class Test {

	public static void main(String[] args) {
		Service service = new Service();
		//两个线程同时操作同一个service对象
		A a = new A(service); // 同一个service对象
		B b = new B(service); // 同一个service对象
		
		Thread t1 = new Thread(a, "线程1");
		Thread t2 = new Thread(b, "线程2");
		
		//启动线程
		t1.start();
		t2.start();
	}

}

运行结果：可以多运行几次

运行结果，情况1

运行结果，情况2

Test2类

package com.demo.thread6;

public class Test2 {

	public static void main(String[] args) {
		Service service = new Service();
		//两个线程同时操作同一个service对象
		A a = new A(service); // 同一个service对象
		C c = new C(service); // 同一个service对象
		
		Thread t1 = new Thread(a, "线程1");
		Thread t2 = new Thread(c, "线程2");
		
		//启动线程
		t1.start();
		t2.start();
	}

}

运行结果：可以多运行几次

Test3类

package com.demo.thread6;

public class Test3 {

	public static void main(String[] args) {
		Service service = new Service();
		//两个线程同时操作同一个service对象
		D d = new D(service); // 同一个service对象
		B b = new B(service); // 同一个service对象
		
		Thread t1 = new Thread(d, "线程1");
		Thread t2 = new Thread(b, "线程2");
		
		//启动线程
		t1.start();
		t2.start();
	}

}

运行结果：可以多运行几次

运行结果，情况1

运行结果，情况2

Test4类

package com.demo.thread6;

public class Test4 {

	public static void main(String[] args) {
		Service service = new Service();
		//两个线程同时操作同一个service对象
		E e = new E(service); // 同一个service对象
		F f = new F(service); // 同一个service对象
		
		Thread t1 = new Thread(e, "线程1");
		Thread t2 = new Thread(f, "线程2");
		
		//运行结果有2种情况
		/**
		 * 情况1:
		 *运行结果，有可能是线程2先执行同步方法，执行完后，此时线程1再执行同步方法时，一直在wait,程
		 *序一直在wait，程序一直没结束
		 */

		/**
		 * 情况2:
		 *运行结果，也有可能是线程1先执行同步方法，然后在执行过程中wait，然后此时释放锁，由线程2执行同步方法，在执
		 *行过程中调用了notifyAll()函数 ,然后唤醒了线程1，线程1继续执行后面的代码
		 * 
		 */

		//启动线程
		t1.start();
		t2.start();
	}

}

运行结果：可以多运行几次

运行结果，情况1

运行结果，情况2

Test5类

package com.demo.thread6;

public class Test5 {

	public static void main(String[] args) {
		Service service = new Service();
		
		//只有当一个线程执行完对象的同步方法之后，另一个线程才会执行同一个对象的同步方法
		//两个线程同时操作同一个service对象
		G g = new G(service); // 同一个service对象
		H h = new H(service); // 同一个service对象
		
		Thread t1 = new Thread(g, "线程1");
		Thread t2 = new Thread(h, "线程2");
		
		//启动线程
		t1.start();
		t2.start();
	}

}

运行结果：可以多运行几次

运行结果，情况1

运行结果，情况2

程宇寒
关注
  • 0
    点赞
  • 踩
  • 4
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
sleep() 方法在synchronized代码块 里/外的区别
扛麻袋的少年的博客
12-20 2778
多线程笔记(十五)：前言 sleep() 休眠，在 synchronized{...}同步代码块 里/外 执行，有着千然之别，接下来我们以实际例子来介绍一下他们之间又如何差别。 本例中 TimeUnit.SECONDS.sleep(1) 与 Thread.sleep(1000) 都是休眠 1s，前者只是对后者进行了一层封装。前者底层的实现还是调用的后者。 实例 1.sl...
java 线程之对象的同步和异步(实例讲解)
08-29
在上面的代码中，我们没有使用 synchronized 关键字，因此线程 thread2 执行 method2() 方法时，不需要等待 thread1 释放锁，可以直接执行。 二、数据的脏读 在多线程环境下，数据的一致性问题是非常重要的。如果...
java sleep方法_Java并发 Synchronized及其实现原理
weixin_39593354的博客
11-29 187
Synchronized是Java中解决并发问题的一种最常用的方法，也是最简单的一种方法。Synchronized的作用主要有三个：(1)确保线程互斥的访问同步代码(2)保证共享变量的修改能够及时可见(3)有效解决重排序问题。Java中每一个对象都可以作为锁，这是synchronized实现同步的基础：1、普通同步方法，锁是当前实例对象public class SynchronizedTest {...
java多线程之synchronized详解
最新发布
qq_43022896的博客
06-03 1063
通过4问题，我们可以看到，通常情况下，为了保证多线程间的有效并发， 会要求每个线程持有锁的时间尽可能短，但是大某些情况下，一个程序对同一个锁不间断、高频地请求、同步与释放， 会消耗掉一定的系统资源，因为锁的讲求、同步与释放本身会带来性能损耗， 这样高频的锁请求就反而不利于系统性能的优化了，虽然单次同步操作的时间可能很短。每个对象都有一个监视器。当锁处于偏向锁状态后，这时出现了一个搅局者，被另外的线程访问了，这时偏向锁就会升级为轻量级锁，其他线程会通过自旋的形式尝试获取锁，但是不会阻塞，从而提高了性能。
java---synchronized和sleep
lijinghqf的专栏
03-05 2143
  被synchronized作用的对象线程，该线程sleep后，马上别的线程会接着执行。看下面程序的执行结果：t1:0t2:0t2:1t1:1t1:2t2:2t2:3t1:3如果将   Thread.sleep(3000);注释掉，那么执行的结果变为：t1:0t1:1t1:2t1:3t2:0t2:1t2:2t2:3 public class TestThread{  
Java中synchronized,sleep()和wait()的初略认知
kunfd的博客
08-14 1200
最近学习刚Java中锁的概念（是看着传智的视频看的） 先来说说synchronized吧，一开始没有认真思考，一直以为synchronized是把整个区域锁了起来，后来才知道原来它的作用是把一个对象锁了起来，也就是说即使他修饰的是整段代码，当对象改变的时候，程序依旧可以访问那段代码。如果依旧要使用synchronized，那么操作的时候一定要操作同一个对象，这样synchronized才可以起作
java中的同步关键字,java线程中的synchronized同步关键字和sleep()函数
weixin_30213173的博客
03-14 164
java线程中的synchronized同步关键字和sleep()函数直接po代码和截图Student类package com.demo.thread4;public class Student{public synchronized void hello1() {System.out.println("我是同步方法hello1()******");try {Thread.sleep(4000);...
Java多线程-同步机制解决线程安全问题方式二：同步方法
01-30
同步方法通过在方法前加上`synchronized`关键字来实现，确保同一时间只有一个线程可以执行该方法。 一、同步方法 1. 同步方法案例1 在案例中，我们有一个`SaleTicket2`类，它实现了`Runnable`接口，并且包含了一个...
java多线程案例-龟兔赛跑
11-01
在Java编程中，多线程是一项重要的技术，它允许程序同时执行多个任务，极大地提高了程序的效率和响应性。在这个“java多线程案例-龟兔赛跑”中，我们将探讨如何利用Java实现一个经典的并发编程示例，即模拟龟兔赛跑...
java多线程经典案例
01-15
Java提供了多种同步机制，如synchronized关键字、Lock接口（ReentrantLock、ReentrantReadWriteLock）以及Semaphore信号量。synchronized用于方法或代码块，可以保证同一时间只有一个线程执行特定代码，避免数据冲突...
java多线程、锁的教程跟案例
12-01
- synchronized关键字：用于控制对共享资源的访问，确保同一时刻只有一个线程访问。 - wait(), notify(), notifyAll()：Object类的方法，用于线程间的通信，通常配合synchronized使用。 二、Java锁机制 1. **内置...
Java面试——并发问题（sleep、synchronized、volatile等）
student_hwj的博客
09-16 472
1.8之前ConcurrentHashMap使用了Segment+数组＋链表的结构，每个Segment对应一把锁，如果多个线程访问不同的Segment，则不会冲突。1.8开始ConcurrentHashMap将数组的每个头节点作为锁，如果多个线程访问的头节点不同，则不会冲突。Hashtable并发度低，整个Hashtable对应一把锁，同一时刻，只能有一个线程操作它。Hashtable初始数组大小是11、扩容阈值是超过3/4，扩容数量是原容量*2+1。3.keepAliveTime 生存时间。
【转载】synchronized里sleep的作用
cc_的博客
07-15 1109
打个比方：一个object就像一个大房子，大门永远打开。房子里有 很多房间（也就是方法）。这些房间有上锁的（synchronized方法）， 和不上锁之分（普通方法）。房门口放着一把钥匙（key），这把钥匙可以打开所有上锁的房间。另外我把所有想调用该对象方法的线程比喻成想进入这房子某个 房间的人。所有的东西就这么多了，下面我们看看这些东西之间如何作用的。 在此我们先来明确一下我们的前提条件。该对象...
synchronized ，notify()，wait()，Thread.sleep();
chuohuan3037的博客
04-08 111
在java中当需要实现同步的时候使用synchronized(对象实例){} synchronized(对象实例){}的作用：是获取一个对象锁 wait()，notify()只能放在synchronized里面使用否则会报java.lang.IllegalMonitorStateExce...
Java中 synchronized
qq_23173183的博客
07-27 168
无论是同步方法还是同步代码块，都是只针对一个对象的多线程而言的。只有同一个对象产生的多线程，才会考虑到同步方法或者同步块。 synchronized关键字，它包括两种方法：synchronized方法和synchronized块。 1.synchronized方法：通过在方法声明中加入synchronized关键字来声明synchronized方法。 public synchronized
synchronized和sleep的用法（1）
yccowdy的博客
08-13 1271
synchronized和sleep的用法（1） 概述：我们都知道synchronized用做同步使之线程安全，然而 synchronized并不总是线程同步 代码实例： `package ThreadPackage; public class ThreadSafe { public static void main(String[] args) { HasSelf numself=
【线程API】sleep用法、Synchronized的两种使用方式、互斥锁的用法、守护线程、多线程并发安全问题等
qq_36028783的博客
01-29 580
守护线程也称为：后台线程守护线程是，通过普通线程调用方法设置而来的，因此创建上与普通线程无异。守护线程的结束时机上有一点与普通线程不同，即：进程的结束.进程结束：当一个java进程中的所有普通线程 都结束时，该进程就会结束，此时会杀掉所有正在运行的 守护线程PS：通常当我们不关心某个线程的任务什么时候停下来，它可以一直运行，但是程序主要的工作都结束时它应当跟着结束时，这样的任务就适合放在守护线程上执行。比如GC就是在守护线程上运行的.​​​​​​​。
线程sleep与synchronized解锁，sleep写在synchronized外面与里面的区别。
weixin_43289848的博客
12-16 1604
结论：当sleep写在synchronized里面的时候，当前线程会休眠，让出cpu,但是synchronized不会解锁，synchronized锁定的方法或者代码块不会往下执行，临界资源别的线程不能用。 结论：当sleep写在synchronized外面的时候，当前线程会休眠，让出cpu,写在外面就和锁没关系了，临界资源别的线程也就可以用了，只不过是让当前线程休息一会罢了。 结论出场景：来自于java实验课的一个多线程售票实验（花了一下午才明白其中的奥秘） 题目要求： ...
多线程中对关于synchronized，sleep以及wait，notify的一些理解
weixin_51598120的博客
12-10 505
唤醒之后子线程并不会重新判断if中的条件是否符合，直接继续执行下去（多线程推荐使用while循环判断）
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值