java-编码笔记-线程实验-锁对象和锁函数的区别

最新推荐文章于 2024-01-31 16:07:13 发布
原创 最新推荐文章于 2024-01-31 16:07:13 发布 · 277 阅读 · 0 ·
CC 4.0 BY-SA版权
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。

本文通过一系列实验，探讨了Java中线程同步的不同方法，包括锁对象和锁函数，以及它们对读写操作的影响。实验表明，锁函数可以防止同一函数内的并发执行，但不影响其他线程读取；而锁对象则限制了对象级别的访问，确保了写操作的互斥，同时也允许其他线程进行读取。

一 线程分析

1.在主线程中调用的线程中的函数，是在主线程中吗？确认是。

2.对象被其他线程锁住，主线程能进行设置吗？能

3.对象设置的函数被锁住，其他线程能对其中的变量进行设置吗？确认，不能。（这里只是实验结果，对象都没锁住，这里怎么可能锁住呢，难道被锁住的全部数据都不允许其他线程写了吗？待确认）

4.变量被锁期间，其他线程可以读吗？可以。

二 代码实验

2.1.试验1

线程中的函数，和在主线程中直接调用，是处在同一线程吗？

确认：不是

2.1.1 代码

package testJava2;

import java.text.SimpleDateFormat;
import java.util.Calendar;
import java.util.Date;

public class XianChengShuo {
	public static void main(String[] args) {
		System.out.println("线程实验？");
		System.out.println("锁对象和锁函数的差别？");
		XianChengShuo ccs = new XianChengShuo();
		ccs.main();
	}
	void main() {
		MyThread myThread = new MyThread();
		// 这两个函数在同一进程中吗
		new Thread(myThread).start();
		for (int i = 0; i < 5; i++) {
			myThread.play();
		}
	}

	class MyThread implements Runnable {
		public int numb = 0;

		public void run() {
			Date date = new Date();
			Calendar beforeTime = Calendar.getInstance();
			beforeTime.add(Calendar.MINUTE, 5);
			Date endDate = beforeTime.getTime();
			while (true) {
				add();
				Date courentDae = new Date();
				// 5分钟后自动停止
				if(courentDae.after(endDate)) {
					System.out.println("线程退出");
					break;
				}
			}
		}
		public void add() {
			String funName = "add";
			playTime(true, funName);
			numb++;
			sleep(100l);
			playTime(false, funName);
		}

		public void play() {
			String funName = "play";
			playTime(true, funName);
			System.out.println(numb);
			sleep(50l);
			playTime(false, funName);
		}

		private void sleep(Long shijian) {
			try {
				Thread.sleep(shijian);
			} catch (Exception e) {

			}
		}

		private void playTime(boolean isStart, String funName) {
			Thread t = Thread.currentThread();
			String name = t.getName();
			String isEnd = "end:";
			if (isStart) {
				isEnd = "start:";
			}
			Date d = new Date();
			SimpleDateFormat sdf = new SimpleDateFormat(
					"yyyy-MM-dd HH:mm:ss.sss");
			String sj = sdf.format(d);

			System.out.println(
					"线程名称" + name + " 函数名" + funName + " " + isEnd + sj);
		}
	}
}

2.1.2 运行结果 

线程实验？
锁对象和锁函数的差别？
线程名称Thread-0 函数名add start:2020-09-24 09:52:43.043
线程名称main 函数名play start:2020-09-24 09:52:43.043
1
线程名称main 函数名play end:2020-09-24 09:52:43.043
线程名称main 函数名play start:2020-09-24 09:52:43.043
1
线程名称Thread-0 函数名add end:2020-09-24 09:52:43.043
线程名称main 函数名play end:2020-09-24 09:52:43.043
线程名称Thread-0 函数名add start:2020-09-24 09:52:43.043
线程名称main 函数名play start:2020-09-24 09:52:43.043
2
线程名称main 函数名play end:2020-09-24 09:52:43.043
线程名称main 函数名play start:2020-09-24 09:52:43.043
2
线程名称Thread-0 函数名add end:2020-09-24 09:52:43.043
线程名称main 函数名play end:2020-09-24 09:52:43.043
线程名称Thread-0 函数名add start:2020-09-24 09:52:43.043
线程名称main 函数名play start:2020-09-24 09:52:43.043
3
线程名称main 函数名play end:2020-09-24 09:52:43.043
线程名称Thread-0 函数名add end:2020-09-24 09:52:43.043
线程名称Thread-0 函数名add start:2020-09-24 09:52:43.043
线程名称Thread-0 函数名add end:2020-09-24 09:52:44.044
线程名称Thread-0 函数名add start:2020-09-24 09:52:44.044
线程名称Thread-0 函数名add end:2020-09-24 09:52:44.044
线程名称Thread-0 函数名add start:2020-09-24 09:52:44.044
线程名称Thread-0 函数名add end:2020-09-24 09:52:44.044
线程名称Thread-0 函数名add start:2020-09-24 09:52:44.044
线程名称Thread-0 函数名add end:2020-09-24 09:52:44.044
线程名称Thread-0 函数名add start:2020-09-24 09:52:44.044
线程名称Thread-0 函数名add end:2020-09-24 09:52:44.044

2.1. 3 代码分析

2.2 实验2 

锁函数：锁函数后，线程set的对象仍然可以被get

2.2.1 代码 

package testJava2;

import java.text.SimpleDateFormat;
import java.util.Calendar;
import java.util.Date;

public class XianChengShuo {
	public static void main(String[] args) {
		System.out.println("线程实验？");
		System.out.println("锁对象和锁函数的差别？");
		XianChengShuo ccs = new XianChengShuo();
		ccs.main();
	}
	void main() {
		MyThread myThread = new MyThread();
		// 这两个函数在同一进程中吗
		new Thread(myThread).start();
		for (int i = 0; i < 5; i++) {
			myThread.play();
		}
	}

	class MyThread implements Runnable {
		public int numb = 0;

		public void run() {
			Date date = new Date();
			Calendar beforeTime = Calendar.getInstance();
			beforeTime.add(Calendar.MINUTE, 1);
			Date endDate = beforeTime.getTime();
			while (true) {
				add();
				Date courentDae = new Date();
				// 5分钟后自动停止
				if(courentDae.after(endDate)) {
					System.out.println("线程退出");
					break;
				}
			}
		}
		//锁函数
		public synchronized void add() {
			String funName = "add";
			playTime(true, funName);
			numb++;
			sleep(100l);
			playTime(false, funName);
		}

		public void play() {
			String funName = "play";
			playTime(true, funName);
			System.out.println(numb);
			sleep(50l);
			playTime(false, funName);
		}

		private void sleep(Long shijian) {
			try {
				Thread.sleep(shijian);
			} catch (Exception e) {

			}
		}

		private void playTime(boolean isStart, String funName) {
			Thread t = Thread.currentThread();
			String name = t.getName();
			String isEnd = "end:";
			if (isStart) {
				isEnd = "start:";
			}
			Date d = new Date();
			SimpleDateFormat sdf = new SimpleDateFormat(
					"yyyy-MM-dd HH:mm:ss.sss");
			String sj = sdf.format(d);

			System.out.println(
					"线程名称" + name + " 函数名" + funName + " " + isEnd + sj);
		}
	}
}

2.2 .2 运行结果 

线程实验？
锁对象和锁函数的差别？
线程名称Thread-0 函数名add start:2020-09-24 09:58:07.007
线程名称main 函数名play start:2020-09-24 09:58:07.007
1
线程名称main 函数名play end:2020-09-24 09:58:07.007
线程名称main 函数名play start:2020-09-24 09:58:07.007
1
线程名称main 函数名play end:2020-09-24 09:58:07.007
线程名称Thread-0 函数名add end:2020-09-24 09:58:07.007
线程名称main 函数名play start:2020-09-24 09:58:07.007
1
线程名称Thread-0 函数名add start:2020-09-24 09:58:07.007
线程名称main 函数名play end:2020-09-24 09:58:07.007
线程名称main 函数名play start:2020-09-24 09:58:07.007
2
线程名称Thread-0 函数名add end:2020-09-24 09:58:07.007
线程名称main 函数名play end:2020-09-24 09:58:07.007
线程名称main 函数名play start:2020-09-24 09:58:07.007
2
线程名称Thread-0 函数名add start:2020-09-24 09:58:07.007
线程名称main 函数名play end:2020-09-24 09:58:07.007
线程名称Thread-0 函数名add end:2020-09-24 09:58:08.008
线程名称Thread-0 函数名add start:2020-09-24 09:58:08.008
线程名称Thread-0 函数名add end:2020-09-24 09:58:08.008

2.2.3 代码分析 

2.3 实验3

目的：锁对象是否影响其他线程读，确认没有影响

2.3.1 代码

package testJava2;

import java.text.SimpleDateFormat;
import java.util.Calendar;
import java.util.Date;

public class XianChengShuo {
	public static void main(String[] args) {
		System.out.println("线程实验？");
		System.out.println("锁对象和锁函数的差别？");
		XianChengShuo ccs = new XianChengShuo();
		ccs.main();
	}
	void main() {
		MyThread myThread = new MyThread();
		// 这两个函数在同一进程中吗
		new Thread(myThread).start();
		for (int i = 0; i < 5; i++) {
			myThread.play();
			//myThread.set(i);
		}
	}

	class MyThread implements Runnable {
		public Integer numb = 0;

		public void run() {
			Date date = new Date();
			Calendar beforeTime = Calendar.getInstance();
			beforeTime.add(Calendar.MINUTE, 1);
			Date endDate = beforeTime.getTime();
			while (true) {
				add();
				Date courentDae = new Date();
				// 5分钟后自动停止
				if(courentDae.after(endDate)) {
					System.out.println("线程退出");
					break;
				}
			}
		}
		//锁对象
		public void add() {
			synchronized(numb) {
				String funName = "add";
				playTime(true, funName);
				numb++;
				sleep(1000l);
				playTime(false, funName);
			}
		}

		public void play() {
			String funName = "play";
			playTime(true, funName);
			System.out.println(numb);
			sleep(500l);
			playTime(false, funName);
		}
		/*
		 * public void set(int value) { String funName = "set"; playTime(true,
		 * funName); numb = value;
		 * System.out.println("numb:"+numb+" value"+value); sleep(50l);
		 * playTime(false, funName); }
		 */

		private void sleep(Long shijian) {
			try {
				Thread.sleep(shijian);
			} catch (Exception e) {

			}
		}

		private void playTime(boolean isStart, String funName) {
			Thread t = Thread.currentThread();
			String name = t.getName();
			String isEnd = "end:";
			if (isStart) {
				isEnd = "start:";
			}
			Date d = new Date();
			SimpleDateFormat sdf = new SimpleDateFormat(
					"yyyy-MM-dd HH:mm:ss.sss");
			String sj = sdf.format(d);

			System.out.println(
					"线程名称" + name + " 函数名" + funName + " " + isEnd + sj);
		}
	}
}

2.3.2 运行结果 

线程实验？
锁对象和锁函数的差别？
线程名称main 函数名play start:2020-09-24 10:24:13.013
线程名称Thread-0 函数名add start:2020-09-24 10:24:13.013
0
线程名称main 函数名play end:2020-09-24 10:24:13.013
线程名称main 函数名play start:2020-09-24 10:24:13.013
1
线程名称Thread-0 函数名add end:2020-09-24 10:24:14.014
线程名称Thread-0 函数名add start:2020-09-24 10:24:14.014
线程名称main 函数名play end:2020-09-24 10:24:14.014
线程名称main 函数名play start:2020-09-24 10:24:14.014
2
线程名称main 函数名play end:2020-09-24 10:24:14.014
线程名称main 函数名play start:2020-09-24 10:24:14.014
2
线程名称main 函数名play end:2020-09-24 10:24:15.015
线程名称Thread-0 函数名add end:2020-09-24 10:24:15.015
线程名称main 函数名play start:2020-09-24 10:24:15.015
线程名称Thread-0 函数名add start:2020-09-24 10:24:15.015
2
线程名称main 函数名play end:2020-09-24 10:24:15.015
线程名称Thread-0 函数名add end:2020-09-24 10:24:16.016

2.3.3 代码分析 

2.4 实验4

目的：锁对象是否影响其他线程写

2.4.1 代码

package testJava2;

import java.text.SimpleDateFormat;
import java.util.Calendar;
import java.util.Date;

public class XianChengShuo {
	public static void main(String[] args) {
		System.out.println("线程实验？");
		System.out.println("锁对象和锁函数的差别？");
		XianChengShuo ccs = new XianChengShuo();
		ccs.main();
	}
	void main() {
		MyThread myThread = new MyThread();
		// 这两个函数在同一进程中吗
		new Thread(myThread).start();
		for (int i = 0; i < 5; i++) {
			myThread.play();
			myThread.set(i);
		}
	}

	class MyThread implements Runnable {
		public Integer numb = 0;

		public void run() {
			Date date = new Date();
			Calendar beforeTime = Calendar.getInstance();
			beforeTime.add(Calendar.MINUTE, 1);
			Date endDate = beforeTime.getTime();
			while (true) {
				add();
				Date courentDae = new Date();
				// 5分钟后自动停止
				if(courentDae.after(endDate)) {
					System.out.println("线程退出");
					break;
				}
			}
		}
		//锁对象
		public void add() {
			synchronized(numb) {
				String funName = "add";
				playTime(true, funName);
				numb++;
				sleep(1000l);
				playTime(false, funName);
			}
		}

		public void play() {
			String funName = "play";
			playTime(true, funName);
			System.out.println(numb);
			sleep(500l);
			playTime(false, funName);
		}
		public void set(int value) {
			String funName = "set";
			playTime(true, funName);
			numb = value;
			System.out.println("numb:"+numb+" value"+value);
			sleep(50l);
			playTime(false, funName);
		}

		private void sleep(Long shijian) {
			try {
				Thread.sleep(shijian);
			} catch (Exception e) {

			}
		}

		private void playTime(boolean isStart, String funName) {
			Thread t = Thread.currentThread();
			String name = t.getName();
			String isEnd = "end:";
			if (isStart) {
				isEnd = "start:";
			}
			Date d = new Date();
			SimpleDateFormat sdf = new SimpleDateFormat(
					"yyyy-MM-dd HH:mm:ss.sss");
			String sj = sdf.format(d);

			System.out.println(
					"线程名称" + name + " 函数名" + funName + " " + isEnd + sj);
		}
	}
}

2.4.2 运行结果

线程实验？
锁对象和锁函数的差别？
线程名称Thread-0 函数名add start:2020-09-24 10:16:08.008
线程名称main 函数名play start:2020-09-24 10:16:08.008
1
线程名称main 函数名play end:2020-09-24 10:16:09.009
线程名称main 函数名set start:2020-09-24 10:16:09.009
numb:0 value0
线程名称main 函数名set end:2020-09-24 10:16:09.009
线程名称main 函数名play start:2020-09-24 10:16:09.009
0
线程名称Thread-0 函数名add end:2020-09-24 10:16:09.009
线程名称Thread-0 函数名add start:2020-09-24 10:16:09.009
线程名称main 函数名play end:2020-09-24 10:16:09.009
线程名称main 函数名set start:2020-09-24 10:16:09.009
numb:1 value1
线程名称main 函数名set end:2020-09-24 10:16:09.009
线程名称main 函数名play start:2020-09-24 10:16:09.009
1
线程名称main 函数名play end:2020-09-24 10:16:10.010
线程名称main 函数名set start:2020-09-24 10:16:10.010
numb:2 value2
线程名称main 函数名set end:2020-09-24 10:16:10.010
线程名称main 函数名play start:2020-09-24 10:16:10.010
2
线程名称Thread-0 函数名add end:2020-09-24 10:16:10.010
线程名称Thread-0 函数名add start:2020-09-24 10:16:10.010
线程名称main 函数名play end:2020-09-24 10:16:11.011
线程名称main 函数名set start:2020-09-24 10:16:11.011
numb:3 value3
线程名称main 函数名set end:2020-09-24 10:16:11.011
线程名称main 函数名play start:2020-09-24 10:16:11.011
3
线程名称main 函数名play end:2020-09-24 10:16:11.011
线程名称main 函数名set start:2020-09-24 10:16:11.011
numb:4 value4
线程名称main 函数名set end:2020-09-24 10:16:11.011
线程名称Thread-0 函数名add end:2020-09-24 10:16:11.011

2.4.3 代码分析 

2.5

2.5.1  实验5-1

2.5.1.1 代码

package testJava2;

import java.text.SimpleDateFormat;
import java.util.Calendar;
import java.util.Date;

public class XianChengShuo {
	public static void main(String[] args) {
		System.out.println("线程实验？");
		System.out.println("锁对象和锁函数的差别？");
		XianChengShuo ccs = new XianChengShuo();
		ccs.main();
	}
	void main() {
		MyThread myThread = new MyThread();
		// 这两个函数在同一进程中吗
		new Thread(myThread).start();
		for (int i = 0; i < 5; i++) {
			myThread.play();
			myThread.set(i);
		}
	}

	class MyThread implements Runnable {
		public Integer numb = 0;

		public void run() {
			Date date = new Date();
			Calendar beforeTime = Calendar.getInstance();
			beforeTime.add(Calendar.MINUTE, 1);
			Date endDate = beforeTime.getTime();
			while (true) {
				add();
				Date courentDae = new Date();
				// 5分钟后自动停止
				if (courentDae.after(endDate)) {
					System.out.println("线程退出");
					break;
				}
			}
		}
		// 锁对象
		public void add() {
			synchronized (numb) {
				String funName = "add"+numb;
				playTime(true, funName);
				System.out.println("add:"+(++numb));
				sleep(1000l);
				numb++;
				System.out.println("add:"+(++numb));
				playTime(false, funName);
			}
		}

		public void play() {
			String funName = "play";
			playTime(true, funName);
			System.out.println(numb);
			sleep(500l);
			playTime(false, funName);
		}

		public void set(int value) {
			String funName = "set";
			playTime(true, funName);
			numb = value;
			System.out.println("numb:" + numb + " value" + value);
			sleep(1000l);
			playTime(false, funName);
		}

		private void sleep(Long shijian) {
			try {
				Thread.sleep(shijian);
			} catch (Exception e) {

			}
		}

		private void playTime(boolean isStart, String funName) {
			Thread t = Thread.currentThread();
			String name = t.getName();
			String isEnd = "end:";
			if (isStart) {
				isEnd = "start:";
			}
			Date d = new Date();
			SimpleDateFormat sdf = new SimpleDateFormat(
					"yyyy-MM-dd HH:mm:ss.sss");
			String sj = sdf.format(d);

			System.out.println(
					"线程名称" + name + " 函数名" + funName + " " + isEnd + sj);
		}
	}
}

2.5.1.2 结果 

线程实验？
锁对象和锁函数的差别？
线程名称Thread-0 函数名add0 start:2020-09-24 10:34:06.006
线程名称main 函数名play start:2020-09-24 10:34:06.006
add:1
1
线程名称main 函数名play end:2020-09-24 10:34:06.006
线程名称main 函数名set start:2020-09-24 10:34:06.006
numb:0 value0
add:2
线程名称Thread-0 函数名add0 end:2020-09-24 10:34:07.007
线程名称Thread-0 函数名add2 start:2020-09-24 10:34:07.007
add:3
线程名称main 函数名set end:2020-09-24 10:34:07.007
线程名称main 函数名play start:2020-09-24 10:34:07.007
3
add:5
线程名称main 函数名play end:2020-09-24 10:34:08.008
线程名称Thread-0 函数名add2 end:2020-09-24 10:34:08.008
线程名称main 函数名set start:2020-09-24 10:34:08.008
numb:1 value1
线程名称Thread-0 函数名add5 start:2020-09-24 10:34:08.008
add:2
add:4
线程名称Thread-0 函数名add5 end:2020-09-24 10:34:09.009
线程名称main 函数名set end:2020-09-24 10:34:09.009
线程名称Thread-0 函数名add4 start:2020-09-24 10:34:09.009
add:5
线程名称main 函数名play start:2020-09-24 10:34:09.009
5
线程名称main 函数名play end:2020-09-24 10:34:09.009
线程名称main 函数名set start:2020-09-24 10:34:09.009
numb:2 value2

2.5.1.3 代码分析 

2.5.2 实验5-2

2.5.2.1 代码

package testJava2;

import java.text.SimpleDateFormat;
import java.util.Calendar;
import java.util.Date;

public class XianChengShuo {
	public static void main(String[] args) {
		System.out.println("线程实验？");
		System.out.println("锁对象和锁函数的差别？");
		XianChengShuo ccs = new XianChengShuo();
		ccs.main();
	}
	void main() {
		MyThread myThread = new MyThread();
		// 这两个函数在同一进程中吗
		new Thread(myThread).start();
		for (int i = 0; i < 5; i++) {
			myThread.play();
			myThread.set(i);
		}
	}

	class MyThread implements Runnable {
		public Integer numb = 0;

		public void run() {
			Date date = new Date();
			Calendar beforeTime = Calendar.getInstance();
			beforeTime.add(Calendar.MINUTE, 1);
			Date endDate = beforeTime.getTime();
			while (true) {
				add();
				Date courentDae = new Date();
				// 5分钟后自动停止
				if (courentDae.after(endDate)) {
					System.out.println("线程退出");
					break;
				}
			}
		}
		// 锁对象
		public synchronized void add() {
			String funName = "add"+numb;
			playTime(true, funName);
			System.out.println("add:"+(++numb));
			sleep(1000l);
			numb++;
			System.out.println("add:"+(++numb));
			playTime(false, funName);
		}

		public void play() {
			String funName = "play";
			playTime(true, funName);
			System.out.println(numb);
			sleep(500l);
			playTime(false, funName);
		}

		public synchronized void set(int value) {
			String funName = "set";
			playTime(true, funName);
			numb = value;
			System.out.println("numb:" + numb + " value" + value);
			sleep(1000l);
			playTime(false, funName);
		}

		private void sleep(Long shijian) {
			try {
				Thread.sleep(shijian);
			} catch (Exception e) {

			}
		}

		private void playTime(boolean isStart, String funName) {
			Thread t = Thread.currentThread();
			String name = t.getName();
			String isEnd = "end:";
			if (isStart) {
				isEnd = "start:";
			}
			Date d = new Date();
			SimpleDateFormat sdf = new SimpleDateFormat(
					"yyyy-MM-dd HH:mm:ss.sss");
			String sj = sdf.format(d);

			System.out.println(
					"线程名称" + name + " 函数名" + funName + " " + isEnd + sj);
		}
	}
}

2.5.2.2 

线程实验？
锁对象和锁函数的差别？
线程名称main 函数名play start:2020-09-24 10:45:48.048
线程名称Thread-0 函数名add0 start:2020-09-24 10:45:48.048
0
add:1
线程名称main 函数名play end:2020-09-24 10:45:49.049
add:3
线程名称Thread-0 函数名add0 end:2020-09-24 10:45:49.049
线程名称main 函数名set start:2020-09-24 10:45:49.049
numb:0 value0
线程名称main 函数名set end:2020-09-24 10:45:50.050
线程名称Thread-0 函数名add0 start:2020-09-24 10:45:50.050
add:1
线程名称main 函数名play start:2020-09-24 10:45:50.050
1
线程名称main 函数名play end:2020-09-24 10:45:51.051
add:3
线程名称Thread-0 函数名add0 end:2020-09-24 10:45:51.051
线程名称Thread-0 函数名add3 start:2020-09-24 10:45:51.051
add:4
add:6
线程名称Thread-0 函数名add3 end:2020-09-24 10:45:52.052
线程名称Thread-0 函数名add6 start:2020-09-24 10:45:52.052
add:7
add:9
线程名称Thread-0 函数名add6 end:2020-09-24 10:45:53.053
线程名称Thread-0 函数名add9 start:2020-09-24 10:45:53.053
add:10
add:12
线程名称Thread-0 函数名add9 end:2020-09-24 10:45:54.054
线程名称Thread-0 函数名add12 start:2020-09-24 10:45:54.054
add:13
add:15
线程名称Thread-0 函数名add12 end:2020-09-24 10:45:55.055
线程名称Thread-0 函数名add15 start:2020-09-24 10:45:55.055
add:16
add:18
线程名称Thread-0 函数名add15 end:2020-09-24 10:45:56.056
线程名称main 函数名set start:2020-09-24 10:45:56.056
numb:1 value1
线程名称main 函数名set end:2020-09-24 10:45:57.057
线程名称main 函数名play start:2020-09-24 10:45:57.057
1
线程名称Thread-0 函数名add1 start:2020-09-24 10:45:57.057
add:2
线程名称main 函数名play end:2020-09-24 10:45:58.058
add:4
线程名称Thread-0 函数名add1 end:2020-09-24 10:45:58.058
线程名称Thread-0 函数名add4 start:2020-09-24 10:45:58.058
add:5
add:7
线程名称Thread-0 函数名add4 end:2020-09-24 10:45:59.059
线程名称Thread-0 函数名add7 start:2020-09-24 10:45:59.059
add:8
add:10
线程名称Thread-0 函数名add7 end:2020-09-24 10:46:00.000
线程名称main 函数名set start:2020-09-24 10:46:00.000
numb:2 value2
线程名称main 函数名set end:2020-09-24 10:46:01.001
线程名称Thread-0 函数名add2 start:2020-09-24 10:46:01.001

2.5.2.3 代码分析

黑马程序员Java+AI智能辅助---多线程笔记
2301_77197507的博客
03-18 1094
我认为就是放线程的地方，一个空间里面放大量已经定义好的线程，来了任务就拿已经定义好的线程去完成任务。
Thread.sleep( )线程休眠的优化写法
阿水的博客
05-29 2212
TimeUnit.SECONDS.sleep(10)在可读性和代码清晰性方面略胜一筹，而Thread.sleep(10 * 1000)则需要手动进行单位转换，并且可读性稍差。两者在功能上是等效的，选择使用哪种方式取决于个人偏好和代码风格。
线程——锁
yxt0505的博客
08-12 171
一.同步,竞争,互斥 当多个线程同时访问其共享资源时,需要相互协调,以防止出现数据不一致,不完整问题,能达到这种状态叫线程同步 而有些资源在同一时刻只有一个线程访问,对于这种资源的访问需要竞争 当资源获取到后,能够防止资源被其他线程再次获取的方法叫互斥 二.互斥量(锁) pthread_mutex_t mutex=PTHREAD_MUTEX_INITIALIZER int pthread_...
多线程—— Lock(线程锁)
weixin_37763870的博客
03-10 812
文章目录1.不使用 Lock 的情况2.使用 Lock 的情况 1.不使用 Lock 的情况 函数一：全局变量A的值每次加1，循环10次，并打印 def job1(): global A for i in range(10): A+=1 print('job1',A) 函数二：全局变量A的值每次加10，循环10次，并打印 def job2(): ...
理解 Thread.Sleep 函数
greystar的专栏
04-08 5957
转自http://www.cnblogs.com/ILove/archive/2008/04/07/1140419.html我们可能经常会用到 Thread.Sleep 函数来使线程挂起一段时间。那么你有没有正确的理解这个函数的用法呢？思考下面这两个问题：1、假设现在是 2008-4-7 12:00:00.000，如果我调用一下 Thread.Sleep(1000) ，在 2008-4-7
java中的类锁和对象锁对比分析
boy_chen93的博客
07-25 295
      说到锁机制，不得不提到Thread线程，而又不得不提到synchronized关键字，这个单词的意思是表示“同步”的意思。用它去修饰方法函数的时候，如果有多个线程同时调用这个方法函数的时候，那么当一个线程获得锁的时候，其他的线程只能进入等待队列，直到这根线程执行完毕，释放锁的时候，其他线程才可以获得锁去执行这个方法函数。        这里我们主要讲的是对象锁和类锁。对象锁，顾名思义...
Linux多进程机制和锁（一）线程的创建以及基本函数使用
qq_43393823的博客
04-20 211
进程和线程 进程是程序执行时的一个实例，即它是程序已经执行到何种程度的数据结构的汇集。从内核的观点看，进程的目的就是担当分配系统资源（CPU时间、内存等）的基本单位。 线程是进程的一个执行流，是CPU调度和分派的基本单位，它是比进程更小的能独立运行的基本单位。一个进程由几个线程组成（拥有很多相对独立的执行流的用户程序共享应用程序的大部分数据结构），线程与同属一个进程的其他的线程共享进程所拥有的全部资源。 “进程——资源分配的最小单位，线程——程序执行的最小单位” 进程有独立的地址空间，一个进程崩溃后，在保护
bjy学习笔记-阿里巴巴Java编码规范以及一些技术笔记
03-29
在本压缩包“bjy学习笔记-阿里巴巴Java编码规范以及一些技术笔记”中，我们可以预见到包含的内容主要是关于Java编程语言的学习心得，特别是遵循阿里巴巴的Java编码规范的相关知识。这是一份宝贵的资源，对于Java...
Java-notes:Java语言笔记
04-01
Java 8引入了Optional类来避免空指针异常，Stream API则提供了函数式编程的便利。此外，Guava库提供了更丰富的工具类，如Preconditions、Lists、Maps等，提高了开发效率。 以上五个部分构成了Java编程的基础，掌握...
20-Spring-Java学习笔记脱水版1
08-03
以上是Spring和Java学习笔记中涉及的一些关键知识点，这些知识对于理解和使用Spring框架进行开发至关重要。此外，附录中提供的方法表可以帮助深入理解和记忆Java中常用类和接口的方法，进一步提升编程能力。
个人笔记--JAVA基础
11-25
### 个人笔记--JAVA基础 #### 一、初识Java **1.1. Java语言是什么** Java是一种广泛使用的高级编程语言，由Sun Microsystems于1995年发布。它被设计为简单、面向对象、分布式、解释型、健壮、安全、与体系结构...
线程的休眠#java学习50
weixin_45863084的博客
09-19 405
线程休眠 sleep指当前线程阻塞的毫秒数 sleep存在异常InterruptedException sleep时间达到后线程进入就绪状态 sleep可以模拟网络延时，倒计时等 s每个对象都有一个锁，sleep不会释放锁 多线程模拟购票 public class TestSleep01 implements Runnable{ private int ticketNum=10;//定义的票数 @Override public void run() { whi
javaSE 线程休眠,Thread.sleep()
houyanhua1的专栏
06-19 317
Demo.java：package cn.xxx.demo; public class Demo { public static void main(String[] args) throws Exception{ /*for(int i = 0 ; i &lt; 5 ;i++){ Thread.sleep(50); // 线程休眠 System.out.println(i)...
Java 判断两个Long类型是否相等
追求卓越583的博客
10-23 810
Java 判断两个Long类型是否相等
java数据类型及其类型转换
RYJ359的博客
07-12 422
数据类型是java语言的重要组成部分，应当掌握常用的数据类型。本文简单介绍java编程语言的8种数据类型，类型转换以及转换过程的精度损失等问题。
线程休眠,礼让
weixin_45970171的博客
11-02 835
线程休眠,礼让 线程休眠 sleep(时间)指定当前线程阻塞的毫米值 sleep存在异常InterruptedException; sleep时间达到后线程进入就绪状态 sleep可以模拟网络延迟（就是在run方法中加一个sleep方法就可以了），倒计时等 每一个对象都有一个锁，sleep不会释放锁； package com.Jinone.www; import java.text.SimpleDateFormat; import java.util.Date; public class TextS
Thread.sleep()总结
最新发布
微赚淘客系统开发者博客
01-31 2991
在Java中，是Thread类提供的一个静态方法，用于让当前执行的线程休眠（暂停执行）一段时间。其中，millis参数表示线程休眠的时间，单位是毫秒。调用这个方法会让当前线程暂停执行，进入休眠状态，但不会释放它所持有的任何锁。是控制线程执行速度的重要工具之一。通过合理使用它，我们可以实现线程之间的协同工作，有效地管理程序的执行流程。在实际应用中，根据具体场景和需求，合理选择线程休眠的时间，以达到更好的程序性能和用户体验。希望本文能够帮助你更好地理解和使用方法。
java 多线程模式_[温故]图解java多线程设计模式（二）
weixin_39631953的博客
02-22 142
一、join & interrupt这俩方法属于线程对象里的方法，属于线程本身的操作。1.1：join方法用于等待一个线程的终止，等待期间将会阻塞，直到被等待的线程终止结束。所以join可以用来做多任务异步处理，比如还是拿利用CompletableFuture优化程序的执行效率这篇里的第一个例子做优化，这篇文章里使用线程池的future模式进行多任务异步处理，现在使用join改写下：再来简...
Java8学习笔记：2.Stream流
bai020的博客
01-13 1257
今天学习总结了Stream()，在此备注： 惰性求值方法：类似sql查询的where条件，过滤stream的条件。如：filter() 及早求值函数：类似sql查询的seletct条件，直返结果。如：count()，max() 方法总结： count()：及早求值函数，求总数。 collect()：由Stream里的值生成一个列表，是一个及早求值操作（.of()方法时惰性求值的方法）
Java技术分享：sangwon-note个人学习笔记
个人笔记中可能会包含对以上知识点的细节解释、编码实践、解决方案、设计思路等内容，这些都是学习和掌握Java编程不可或缺的部分。由于笔记的性质，它们可能还会包含特定学习路径、常用资源链接、项目案例分析、以及...
评论
成就一亿技术人!
拼手气红包6.0元
还能输入1000个字符
 
红包 添加红包
表情包 插入表情
表情包 代码片
 条评论被折叠 查看
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值