java 线程通信

最新推荐文章于 2024-01-01 08:03:25 发布
最新推荐文章于 2024-01-01 08:03:25 发布
阅读量527 收藏
点赞数
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/gzbbxu/article/details/22099035
版权 
package com.zkk;

public class Test1 {
	public static void main(String[] args) {
		new Test1().init();
	}

	private void init() {
		final Outputer outputer = new Outputer();// 静态方法中不能new 内部类的实例对象
		new Thread(new Runnable() {
			@Override
			public void run() {
				while (true) {
					try {
						Thread.sleep(10);
					} catch (InterruptedException e) {
						e.printStackTrace();
					}
					outputer.output("zhoukeke");
				}
			}
		}).start();
		
		
		
		new Thread(new Runnable() {
			@Override
			public void run() {
				while (true) {
					try {
						Thread.sleep(10);
					} catch (InterruptedException e) {
						e.printStackTrace();
					}
					outputer.output("zhangsan");
				}
			}
		}).start();
	}

	class Outputer {
		public void output(String name) {
			int len = name.length();
			for (int i = 0; i < len; i++) {
				System.out.print(name.charAt(i));
			}
			System.out.println();
		}
	}
}


以上的代码是有问题的;问题如下


 会打印如图所示的字符串,用张老师的话来说，这是一个奇迹，多线程就会出现这种问题 cpu 跑到另外一个线程上啦

为了防止上述问题，使用同步技术

output 方法中的代码要实现原子性 当有一个线程来执行我的时候，别的线程不能来执行我 ，就像厕所里面的坑一样，有一个人在里面的时候，别人不能进来

在java 中是这么解决问题的，把你要保护的代码用关键字保护起来，排他性 synchronized 


package com.zkk;

public class Test1 {
	public static void main(String[] args) {
		new Test1().init();
	}

	private void init() {
		final Outputer outputer = new Outputer();// 静态方法中不能new 内部类的实例对象
		new Thread(new Runnable() {
			@Override
			public void run() {
				while (true) {
					try {
						Thread.sleep(10);
					} catch (InterruptedException e) {
						e.printStackTrace();
					}
					outputer.output("zhoukeke");
				}
			}
		}).start();

		new Thread(new Runnable() {
			@Override
			public void run() {
				while (true) {
					try {
						Thread.sleep(10);
					} catch (InterruptedException e) {
						e.printStackTrace();
					}
					outputer.output("zhangsan");
				}
			}
		}).start();
	}

	class Outputer {
		String xxx="";
		public void output(String name) {
			int len = name.length();
			synchronized (xxx) {//找任意一个对象就行 这里的对象用name 就不行 使用name 达不到同步的效果 必须是同一个对象
				                 // 使用xxx 对象 就没有奇迹啦
				for (int i = 0; i < len; i++) {
					System.out.print(name.charAt(i));
				}
				System.out.println();
			}
		}
	}
}

其实上述例子还是多此一举，用this 来代表锁 

package com.zkk;

public class Test1 {
	public static void main(String[] args) {
		new Test1().init();
	}

	private void init() {
		final Outputer outputer = new Outputer();// 静态方法中不能new 内部类的实例对象
		new Thread(new Runnable() {
			@Override
			public void run() {
				while (true) {
					try {
						Thread.sleep(10);
					} catch (InterruptedException e) {
						e.printStackTrace();
					}
					outputer.output("zhoukeke");
				}
			}
		}).start();

		new Thread(new Runnable() {
			@Override
			public void run() {
				while (true) {
					try {
						Thread.sleep(10);
					} catch (InterruptedException e) {
						e.printStackTrace();
					}
					outputer.output("zhangsan");
				}
			}
		}).start();
	}

	class Outputer {
		public void output(String name) {
			int len = name.length();
			synchronized (this) {//找任意一个对象就行 这里的对象用name 就不行 使用name 达不到同步的效果 必须是同一个对象
				                 // 使用xxx 对象 就没有奇迹啦
				for (int i = 0; i < len; i++) {
					System.out.print(name.charAt(i));
				}
				System.out.println();
			}
		}
	}
}

方法中使用synchronized 


package com.zkk;

public class Test1 {
	public static void main(String[] args) {
		new Test1().init();
	}

	private void init() {
		final Outputer outputer = new Outputer();// 静态方法中不能new 内部类的实例对象
		new Thread(new Runnable() {
			@Override
			public void run() {
				while (true) {
					try {
						Thread.sleep(10);
					} catch (InterruptedException e) {
						e.printStackTrace();
					}
					outputer.output("zhoukeke");
				}
			}
		}).start();

		new Thread(new Runnable() {
			@Override
			public void run() {
				while (true) {
					try {
						Thread.sleep(10);
					} catch (InterruptedException e) {
						e.printStackTrace();
					}
					outputer.output("zhangsan");
				}
			}
		}).start();
	}

	class Outputer {
		public void output(String name) {
			int len = name.length();
			synchronized (this) {// 找任意一个对象就行 这里的对象用name 就不行 使用name 达不到同步的效果
									// 必须是同一个对象
									// 使用xxx 对象 就没有奇迹啦
				for (int i = 0; i < len; i++) {
					System.out.print(name.charAt(i));
				}
				System.out.println();
			}
		}

		// 方法上使用synchronized 如果方法中再使用synchronized 极有可能出现死锁
		// 方法中的synchronized 使用的锁就是this 对象
		public synchronized void output2(String name) {
			int len = name.length();

			for (int i = 0; i < len; i++) {
				System.out.print(name.charAt(i));
			}
			System.out.println();

		}
	}
}

以下是错误范例output3 方法要相同步 


package com.zkk;

public class Test1 {
	public static void main(String[] args) {
		new Test1().init();
	}

	private void init() {
		final Outputer outputer = new Outputer();// 静态方法中不能new 内部类的实例对象
		new Thread(new Runnable() {
			@Override
			public void run() {
				while (true) {
					try {
						Thread.sleep(10);
					} catch (InterruptedException e) {
						e.printStackTrace();
					}
					outputer.output("zhoukeke");
				}
			}
		}).start();

		new Thread(new Runnable() {
			@Override
			public void run() {
				while (true) {
					try {
						Thread.sleep(10);
					} catch (InterruptedException e) {
						e.printStackTrace();
					}
					outputer.output("zhangsan");
				}
			}
		}).start();
	}

	static class Outputer {// 加static 就相当于外部类
		public void output(String name) {
			int len = name.length();
			synchronized (this) {// 找任意一个对象就行 这里的对象用name 就不行 使用name 达不到同步的效果
									// 必须是同一个对象
									// 使用xxx 对象 就没有奇迹啦
				for (int i = 0; i < len; i++) {
					System.out.print(name.charAt(i));
				}
				System.out.println();
			}
		}

		// 方法上使用synchronized 如果方法中再使用synchronized 极有可能出现死锁
		// 方法中的synchronized 使用的锁就是this 对象
		public synchronized void output2(String name) {
			int len = name.length();

			for (int i = 0; i < len; i++) {
				System.out.print(name.charAt(i));
			}
			System.out.println();

		}

		public static synchronized void output3(String name) {
			int len = name.length();

			for (int i = 0; i < len; i++) {
				System.out.print(name.charAt(i));
			}
			System.out.println();

		}
	}
}

output3,和output2   output3 和output1 要想同步，要使用clazz 对象 

package com.zkk;

public class Test1 {
	public static void main(String[] args) {
		new Test1().init();
	}

	private void init() {
		final Outputer outputer = new Outputer();// 静态方法中不能new 内部类的实例对象
		new Thread(new Runnable() {
			@Override
			public void run() {
				while (true) {
					try {
						Thread.sleep(10);
					} catch (InterruptedException e) {
						e.printStackTrace();
					}
					outputer.output("zhoukeke");
				}
			}
		}).start();

		new Thread(new Runnable() {
			@Override
			public void run() {
				while (true) {
					try {
						Thread.sleep(10);
					} catch (InterruptedException e) {
						e.printStackTrace();
					}
					outputer.output("zhangsan");
				}
			}
		}).start();
	}

	static class Outputer {// 加static 就相当于外部类
		public void output(String name) {
			int len = name.length();
			synchronized (Outputer.class) {// 找任意一个对象就行 这里的对象用name 就不行 使用name 达不到同步的效果
									// 必须是同一个对象
									// 使用xxx 对象 就没有奇迹啦
				for (int i = 0; i < len; i++) {
					System.out.print(name.charAt(i));
				}
				System.out.println();
			}
		}

		// 方法上使用synchronized 如果方法中再使用synchronized 极有可能出现死锁
		// 方法中的synchronized 使用的锁就是this 对象
		public synchronized void output2(String name) {
			int len = name.length();

			for (int i = 0; i < len; i++) {
				System.out.print(name.charAt(i));
			}
			System.out.println();

		}

		public static synchronized void output3(String name) {
			int len = name.length();

			for (int i = 0; i < len; i++) {
				System.out.print(name.charAt(i));
			}
			System.out.println();

		}
	}
}

接下来是线程同步的问题 面试题 线程相关的

子线程循环10次，接着主线程循环100，接着又回到子线程循环10次，接着再回到主线程又循环100，如此循环50次，请写出程序


分析：

1，子线程和主线程一定要互斥 （我做的时候不打扰你，你做的时候不打扰我）


package com.zkk;

//通信
public class Test2 {
	public static void main(String[] args) {
		// 创建两个线程 一个循环100 次，一个循环10 次
		new Thread(new Runnable() {

			@Override
			public void run() {
				for (int i = 1; i <= 50; i++) {
					synchronized (Test2.class) {
						for (int j = 1; j <= 10; j++) {
							System.out.println("sub thread sequece of " + j
									+ ",loop of " + i);
						}
					}
				}
			}
		}).start();

		for (int i = 1; i <= 50; i++) {
			synchronized (Test2.class) {
				for (int j = 1; j <= 10; j++) {
					System.out.println("main thread sequece of " + j
							+ ",loop of " + i);
				}
			}
		}
	}
}

但是以上并不符合要求，没有分组 这个时候，应该怎么办？

 首先，明确面向对象的思想

 servelet 生成cookie ,要对密码进行加密，fileter 解密的时候, 要对cookie 进行解密,但是加密和解密的方法不适合写在他们的身上

应该自定义一个类，有加密和解密的方法 高内聚,低耦合 他们的代码要同步，就叫做有关联 代码如下：

package com.zkk;

//通信
public class Test2 {
	public static void main(String[] args) {
		final Business business = new Business();
		// 创建两个线程 一个循环100 次，一个循环10 次
		new Thread(new Runnable() {

			@Override
			public void run() {
				for (int i = 1; i <= 50; i++) {
					business.sub(i);
				}
			}
		}).start();

		for (int i = 1; i <= 50; i++) {
			business.main(i);
		}
	}

}

class Business {
	public synchronized void sub(int i) {
		for (int j = 1; j <= 10; j++) {
			System.out.println("sub thread sequece of " + j + ",loop of " + i);
		}
	}

	public synchronized void main(int i) {
		for (int j = 1; j <= 100; j++) {
			System.out.println("main thread sequece of " + j + ",loop of " + i);
		}
	}
}

但是此时，打印的结果还是不如符合要求 没有你来我往,没有和谐发展 ,相互之间没有协调，没有通信,相互之间是互斥的做到了。接下来就是通信的问题啦

值得一提的是，如果不用面向对象的方法来做，就会很糟糕，很混乱，好的思想很重要，设计的巧妙，做起来就事半功倍了。

所以要牢牢记住一个原则，经验：要用到共同数据（包括同步锁）或共同的算法，的若干个方法应该归在同一个类身上，这种设计正好提醒了高类聚和程序的健壮性。

接下来就是通信了。


package com.zkk;

//通信
public class Test2 {
	public static void main(String[] args) {
		final Business business = new Business();
		// 创建两个线程 一个循环100 次，一个循环10 次
		new Thread(new Runnable() {

			@Override
			public void run() {
				for (int i = 1; i <= 50; i++) {
					business.sub(i);
				}
			}
		}).start();

		for (int i = 1; i <= 50; i++) {
			business.main(i);
		}
	}

}

class Business {
	private boolean bShouldSub = true;

	public synchronized void sub(int i) {
		if (!bShouldSub) {
			try {
				this.wait();
			} catch (InterruptedException e) {
				e.printStackTrace();
			}
		}
		for (int j = 1; j <= 10; j++) {
			System.out.println("sub thread sequece of " + j + ",loop of " + i);
		}
		bShouldSub = false;
	}

	public synchronized void main(int i) {
		if (bShouldSub) {
			try {
				this.wait();
			} catch (InterruptedException e) {
				e.printStackTrace();
			}
		}
		for (int j = 1; j <= 100; j++) {
			System.out.println("main thread sequece of " + j + ",loop of " + i);
		}
		bShouldSub = true;
	}
}

以上代码还是有问题的,一般情况下是没有问题的,在等着就不好了，要唤醒 下面的代码： 

package com.zkk;

//通信
public class Test2 {
	public static void main(String[] args) {
		final Business business = new Business();
		// 创建两个线程 一个循环100 次，一个循环10 次
		new Thread(new Runnable() {

			@Override
			public void run() {
				for (int i = 1; i <= 50; i++) {
					business.sub(i);
				}
			}
		}).start();

		for (int i = 1; i <= 50; i++) {
			business.main(i);
		}
	}

}

class Business {
	private boolean bShouldSub = true;

	public synchronized void sub(int i) {
		if (!bShouldSub) {
			try {
				this.wait();
			} catch (InterruptedException e) {
				e.printStackTrace();
			}
		}
		for (int j = 1; j <= 10; j++) {
			System.out.println("sub thread sequece of " + j + ",loop of " + i);
		}
		bShouldSub = false;
		this.notify();
	}

	public synchronized void main(int i) {
		if (bShouldSub) {
			try {
				this.wait();
			} catch (InterruptedException e) {
				e.printStackTrace();
			}
		}
		for (int j = 1; j <= 100; j++) {
			System.out.println("main thread sequece of " + j + ",loop of " + i);
		}
		bShouldSub = true;
		this.notify();
	}
}

这样基本就做完了，记住一个原则，自己管理自己的状态,不要让别人插手

锁是上在代表要操作的资源内部方法中，而不是线程代码中！

而以上代码使用whiel 代替if 程序更加的健壮 最终代码如下

package com.zkk;

//通信
public class Test2 {
	public static void main(String[] args) {
		final Business business = new Business();
		// 创建两个线程 一个循环100 次，一个循环10 次
		new Thread(new Runnable() {

			@Override
			public void run() {
				for (int i = 1; i <= 50; i++) {
					business.sub(i);
				}
			}
		}).start();

		for (int i = 1; i <= 50; i++) {
			business.main(i);
		}
	}

}

class Business {
	private boolean bShouldSub = true;

	public synchronized void sub(int i) {
		while (!bShouldSub) {
			try {
				this.wait();
			} catch (InterruptedException e) {
				e.printStackTrace();
			}
		}
		for (int j = 1; j <= 10; j++) {
			System.out.println("sub thread sequece of " + j + ",loop of " + i);
		}
		bShouldSub = false;
		this.notify();
	}

	public synchronized void main(int i) {
		while (bShouldSub) {
			try {
				this.wait();
			} catch (InterruptedException e) {
				e.printStackTrace();
			}
		}
		for (int j = 1; j <= 100; j++) {
			System.out.println("main thread sequece of " + j + ",loop of " + i);
		}
		bShouldSub = true;
		this.notify();
	}
}

文档


synchronized 使用什么对象，wait 就使用什么对象,要不然就会报异常，并且，wait 在synchronized 里面的。

为什么使用while，在有些情况下，他会被假唤醒,(没有被通知的时候唤醒,  spurious wake up 伪唤醒) 噩梦惊醒 使用while 就能防止这种情况







gzbbxu
关注
Java多线程——线程通信
m0_72786443的博客
09-21 652
多线程 线程通信 唤醒 等待线程
深入理解java线程通信
08-25
深入理解 Java 线程通信 Java 线程通信是 Java 编程中一个非常重要的概念，它可以使得多个线程之间能够相互通信和协作，从而实现更加复杂的任务。下面我们将深入理解 Java 线程通信的机制和实现方式。 一、等待...
Java面试宝典2013版（11版块1000题）
热门推荐
语不惊人死不休
10-13 3万+
一. Java基础部分......................................................................................................2 1、一个".java"源文件中是否可以包括多个类（不是内部类）？有什么限制？.....2 2、Java有没有goto?......................
Java 线程间通信
WYSCODER的博客
04-17 5703
Java线程间通信
java线程通信的三种方式
小老鼠的博客
04-02 2736
1、传统的线程通信。 在synchronized修饰的同步方法或者修饰的同步代码块中使用Object类提供的wait(),notify()和notifyAll()3个方法进行线程通信。 关于这3个方法的解释： wait():导致当前线程等待，直到其他线程调用该同步监视器的notify()方法或notifyAll()方法来唤醒该线程。 notify():唤醒在此...
Java线程通信的几种方式
Admans的专栏
06-29 4542
有两个线程，A 线程向一个集合里面依次添加元素“abc”字符串，一共添加十次，当添加到第五次的时候，希望 B 线程能够收到 A 线程的通知，然后 B 线程执行相关的业务操作。线程间通信的模型有两种：共享内存和消息传递，以下方式都是基本这两种模型来实现的。基于 volatile 关键字来实现线程间相互通信是使用共享内存的思想。大致意思就是多个线程同时监听一个变量，当这个变量发生变化的时候 ，线程能够感知并执行相应的业务。这也是最简单的一种实现方式 Object 类提供了线程间通信的方法：wait()、no
【Java 基础篇】Java 线程通信详解
繁依Fanyi的博客
09-20 761
线程通信是指多个线程之间通过共享内存或其他通信机制来传递信息、同步动作或协作完成任务的过程。线程通信的核心目标是确保线程能够按照预定的顺序执行，并且能够安全地访问共享资源。线程同步：确保多个线程之间的操作按照一定的顺序执行，避免竞态条件和数据不一致性问题。线程等待：使线程能够等待某个条件的满足，以便在条件满足时再继续执行。线程通知：使线程能够通知其他线程某个条件已经满足，以便其他线程可以继续执行。线程唤醒：使等待状态的线程被唤醒，以便它们可以继续执行。
java线程间如何通信
weixin_42608299的博客
02-11 876
Java线程之间可以通过以下方式进行通信： 使用 wait() 和 notify() 方法，这需要使用同步代码块或同步方法。在同步代码块或同步方法中，线程可以调用 wait() 方法阻塞，并在其他线程调用 notify() 方法后恢复执行。 使用 CountDownLatch，它是一个同步辅助类，可以让一个线程等待其他线程的完成。 使用 CyclicBarrier，它也是一个同步辅助类，可以...
Java线程间的通信方式
Wdradon的博客
06-27 5370
**定义：**当多个线程共同操作共享的资源时，线程间通过某种方式互相告知自己的状态，以避免无效的资源争夺。通信的方式：**线程同步：**即当有一个线程在对内存进行操作时，其他线程都不可以对这个内存地址进行操作，直到该线程完成操作， 其他线程才能对该内存地址进行操作。同步的话，仅仅传递的是控制信息，就是我什么时候运行结束，你什么时候可以来。对于线程间通信来说，线程间同步可以归纳为线程间通信的一个子集，对于线程通信指的是两个线程之间可以交换一些实时的数据信息，而线程同步只交换一些控制信息。在java中有几个关于
Java线程通信
weixin_43486804的博客
08-21 1万+
我先提出一个例子 接力赛，A，B为一组，A跑的时候BC等待接力棒，B跑的时候AC等待他们没人每轮跑300米，总共跑1200米 其实把ABC当做线程，这便是一个线程通信的例子。 wait（）; 使执行的线程进行等待 notify（）; 使停止的线程继续运行， join（）; 使所属线程正常执行run方法，而当前线程暂时阻塞，有排队的作用 notify与no...
Java多线程及通信方式详解
EverythingAtOnce的博客
01-01 1317
在讨论这个问题之前，首先要知道什么是Java多线程，我们拿个生活中的例子来说，例如在手机上使用软件，你可以同时运行多个应用程序或功能。你可以同时打开浏览器、音乐播放器和社交媒体应用。每个应用程序都在后台独立运行，就像多线程能够同时执行多个任务一样。但是有时候你需要等待某些操作完成才能继续进行。比如当你在等待一个应用加载数据时，你可以同时切换到另一个应用。但是直到数据加载完成，你才能够进行下一步操作。这种等待和切换类似于多线程中的线程间同步和等待操作。
JAVA 线程通信相关知识汇总
08-19
JAVA 线程通信相关知识汇总 JAVA 线程通信是指在 JAVA 多线程环境下，多个线程之间的协作和交互，以达到共同完成任务的目标。JAVA 线程通信相关知识汇总主要介绍了 JAVA 线程通信相关知识，文中讲解非常细致，代码...
深入理解Java 线程通信
08-19
"深入理解Java 线程通信" Java 线程通信是指在 Java 编程语言中，多个线程之间如何进行交流和协作的机制。Java 提供了多种机制来实现线程间的通信，包括使用 wait()、notify() 和 notifyAll() 方法，使用同步锁和 ...
Java线程间的通信方式详解
09-02
本文将详细介绍两种常见的Java线程通信方式：同步和while轮询。 1. 同步（Synchronized） 同步是Java中控制线程并发的一种手段，它通过`synchronized`关键字实现。在Java中，同步主要有两种形式：同步方法（通过在...
1727008980062_36899042-cccb-455e-a366-ade300382e2a.mp3
最新发布
09-22
1727008980062_36899042-cccb-455e-a366-ade300382e2a.mp3
基于Java和Lua的美食社交APP设计源码
09-22
本项目是基于Java和Lua开发的美食社交APP，包含92个文件，其中包括80个Java源代码文件、4个XML配置文件、2个PNG图像文件、2个Lua脚本文件、1个LICENSE文件、1个Markdown文档文件和1个YAML配置文件。此外，还有1个SQL文件。该项目旨在为用户提供一个便捷、高效的美食社交平台，支持美食分享、社交互动、活动组织等功能，以提升用户体验和社区活跃度。
模数转换器(ADC)技术解析及应用指南
09-22
内容概要：本文全面介绍了模数转换器(ADC)的相关知识和技术，包括ADC的基本原理、关键技术参数、不同类型ADC的工作方式及其应用领域。并通过生动的比喻解释ADC的概念，强调其在日常生活中的实际应用，并提供了选型指南以及对未来发展方向进行了预测。 适用人群：具备一定模拟电子基础知识的研发人员及电子工程专业师生。 使用场景及目标：指导相关人员正确理解和选用ADC，并提升对最新发展的认知。适用于工业、消费电子、汽车电子、通讯和医疗器械等行业。 阅读建议：读者应重点学习ADC的关键指标及各参数间的关联性，并尝试联系具体的应用场景来加深理解。此外还推荐读者扩展学习相关设计实例和技术文章，以更好地吸收和运用知识内容。
基于微信小程序的碎片化驾考论文.docx
09-22
基于微信小程序的碎片化驾考论文
Java线程通信详解：等待通知与同步机制
深入理解Java线程通信在软件开发中是一项至关重要的技能，尤其是在处理多线程并发场景时。本文将探讨如何有效地让主线程在所有子线程执行完毕后进行特定操作，以及如何实现线程之间的协作，比如当线程A达到某个条件...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值