Java中级_多线程二

发表于 | 更新于 | 分类于 | 阅读次数：
本文字数： 5.2k | 阅读时长 ≈ 5 分钟

synchronized

1.怎么创建多线程

2.怎么保证多线程修改同一数据的同步性

3.使用线程池创建多线程

时间问题，先看代码

角色类

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
public class Role {

	private String name;
	private Integer hp;
	private Integer ack;

	// 血量减少
	public synchronized int delhp(int hp) {
		while (hp <= 0) {
			try {
				System.out.println("血量为0,等待!");
				this.wait();
			} catch (InterruptedException e) {
				e.printStackTrace();
			}
		}
		hp = hp - 50;
		this.notify();
		return hp;
	}

	// 血量增加
	public synchronized int addhp(int hp) {
		while (hp >= 999) {
			try {
				System.out.println("血量达到上限999,停止恢复!");
				this.wait();
			} catch (InterruptedException e) {
				e.printStackTrace();
			}
		}
		hp = hp + 100;
		this.notify();
		return hp;

	}
}

测试

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
public static void test1() {
		Role role = new Role();
		role.setName("张三");
		role.setHp(500);

		int n = 1;
		// 1.使用的创建线程的方式启动好几线程
		for (int i = 0; i < n; i++) {
			Thread t = new Thread(() -> {
				while (true) {
					int addhp = role.addhp(role.getHp());
					role.setHp(addhp);
					System.out.println(Thread.currentThread().getName() + "线程--加血后:" + role.getHp());
					try {
						Thread.sleep(1000);
					} catch (InterruptedException e) {
						e.printStackTrace();
					}
				}
			}, UUID.randomUUID().toString().substring(0, 5));
			t.start();
		}

		int m = 1;
		// 1.使用的创建线程的方式启动好几线程
		for (int i = 0; i < m; i++) {
			Thread tt = new Thread(() -> {
				while (true) {
					int delhp = role.delhp(role.getHp());
					role.setHp(delhp);
					System.out.println(Thread.currentThread().getName() + "线程掉血--后:" + role.getHp());
					try {
						Thread.sleep(2000);
					} catch (InterruptedException e) {
						e.printStackTrace();
					}
				}
			}, UUID.randomUUID().toString().substring(0, 5));
			tt.start();
		}
	}

结果：

36668线程–加血后:650
36668线程–加血后:600
14a84线程掉血–后:600
36668线程–加血后:700
14a84线程掉血–后:800
36668线程–加血后:800
36668线程–加血后:900
14a84线程掉血–后:1000
36668线程–加血后:1000
血量达到上限999,停止恢复!
14a84线程掉血–后:950
血量达到上限999,停止恢复!

…..

线程池

线程池类

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
public class MyThreadPool {

	// 线程池大小;
	private int poolSize;
	// 任务集合
	LinkedList<Runnable> tasks = new LinkedList<Runnable>();

		
	public MyThreadPool() {
		poolSize = 10;
		synchronized (tasks) {
			for (int i = 0; i < poolSize; i++) {
				new TaskThread("线程" + i).start();
			}
		}
	}

	public void add(Runnable task) {
		synchronized (tasks) {
			tasks.add(task);
			// 唤醒线程池中等待的线程
			tasks.notifyAll();
		}
	}

	// 创建线程任务类
	class TaskThread extends Thread {
		// 构造方法
		public TaskThread(String name) {
			super(name);
		}

		Runnable task;

		public void run() {
			System.out.println("启动:" + this.getName());
			while (true) {
				synchronized (tasks) {
					while (tasks.isEmpty()) {
						System.out.println("没有任务!休息");
						try {
							tasks.wait();
						} catch (InterruptedException e) {
							e.printStackTrace();
						}
					}
					// 从线程池中拿一个线程出来
					task = tasks.removeLast();
					// 唤醒所有线程
					tasks.notifyAll();
				}
				System.out.println(this.getName() + "接到任务,执行");
				task.run();
			}
		}

	}
}

测试

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
public static void main(String[] args) {
//		ThreadPool pool = new ThreadPool();
		MyThreadPool pool = new MyThreadPool();
		Role role = new Role();
		role.setName("张三");
		role.setHp(500);

		for (int i = 0; i < 5; i++) {
			Runnable task = new Runnable() {
				@Override
				public void run() {
					while (true) {
						int addhp = role.addhp(role.getHp());
						role.setHp(addhp);
						System.out.println(Thread.currentThread().getName() + "线程--加血后:" + role.getHp());
						try {
							Thread.sleep(1000);
						} catch (InterruptedException e) {
							e.printStackTrace();
						}
					}
				}
			};
			pool.add(task);
		}
		for (int i = 0; i < 5; i++) {
			Runnable task = new Runnable() {
				@Override
				public void run() {
					while (true) {
						int delhp = role.delhp(role.getHp());
						role.setHp(delhp);
						System.out.println(Thread.currentThread().getName() + "线程掉血--后:" + role.getHp());
						try {
							Thread.sleep(2000);
						} catch (InterruptedException e) {
							e.printStackTrace();
						}
					}
				}
			};
			pool.add(task);
		}
	}

结果:

…

线程9接到任务,执行
线程7接到任务,执行
线程8接到任务,执行
线程7线程–加血后:800
线程9线程–加血后:700
线程6线程–加血后:600
没有任务!休息
线程1接到任务,执行
没有任务!休息
线程8线程–加血后:900
没有任务!休息
线程1线程–加血后:1000
没有任务!休息
线程2接到任务,执行
线程5接到任务,执行

…

最后看一下,wait sleep 区别

类不同 :

​ wait -> object

​ sleep: Thread

锁的释放:

​ wait -> 会释放锁

​ sleep -> 抱着锁睡觉

作用范围:

​ wait :同步代码块中

​ sleep: 没有限制

异常:

​ wait: 不需要捕获异常

​ sleep: 需要捕获异常

小唠嗑：

想更加深入的了解多线程的使用,进看《Java中级_多线程三》篇

本章到这里就结束了，谢谢耐心看到这里的各位Boss,如果觉得有哪里说的不好的地方，还请高抬贵手多多原谅，不惜指教。

最后，谢谢！

---本文结束感谢您的阅读!---