差别

这里会显示出您选择的修订版和当前版本之间的差别。

--- 分享:技术:多线程:多线程编程核心技术整理 [2016/05/30 22:46]
gxx
+++ 分享:技术:多线程:多线程编程核心技术整理 [2016/06/19 18:16] (当前版本)
gxx
@@ 行 797: / 行 797: @@
 [线程A] count=1
 [线程B] count=1
+</code>
+==== 线程的优先级 ====
+  * 取值[1]~[10]的整数，默认值位[5]
+  * 设置优先级setPriority()
+  * 获取优先级getPriority()
+<code java MyThread.java>
+package com.gxx.threads.study.test12;
+/**
+ * 自定义线程类
+ * @author Gxx
+ */
+public class MyThread extends Thread {
+	/**
+	 * 覆盖run方法
+	 */
+	@Override
+	public void run() {
+		System.out.println("run 开始");
+		System.out.println("线程[" + Thread.currentThread().getName() + "]优先级[继承][" + Thread.currentThread().getPriority() + "]");
+		System.out.println("run 结束");
+	}
+}
+</code>
+<code java Test.java>
+package com.gxx.threads.study.test12;
+/**
+ * 测试类－测试线程线程优先级的常量，默认值，范围和继承性
+ * @author Gxx
+ */
+public class Test {
+	/**
+	 * main方法
+	 * @param args
+	 */
+	public static void main(String[] args) {
+		System.out.println("===线程优先级常量=开始======");
+		System.out.println("线程优先级MIN_PRIORITY=" + Thread.MIN_PRIORITY);
+		System.out.println("线程优先级NORM_PRIORITY=" + Thread.NORM_PRIORITY);
+		System.out.println("线程优先级MAX_PRIORITY=" + Thread.MAX_PRIORITY);
+		System.out.println("===线程优先级常量=结束======");
+		System.out.println("main 开始");
+		System.out.println("线程[" + Thread.currentThread().getName() + "]优先级[默认][" + Thread.currentThread().getPriority() + "]");
+		try{
+			System.out.println("=========");
+			System.out.println("线程[" + Thread.currentThread().getName() + "]优先级[设置][11]");
+			Thread.currentThread().setPriority(11);
+		} catch (Exception e){
+			System.out.println("设置[11]失败!");
+			System.out.println("线程优先级设置范围在[" + Thread.MIN_PRIORITY + "]~[" + Thread.MAX_PRIORITY + "]");
+			System.out.println("=========");
+		}
+		/**
+		 * range MIN_PRIORITY to MAX_PRIORITY
+		 * 设置线程优先级必须在[MIN_PRIORITY,MAX_PRIORITY]也就是[1,10]
+		 */
+		Thread.currentThread().setPriority(8);
+		System.out.println("线程[" + Thread.currentThread().getName() + "]优先级[设置][" + Thread.currentThread().getPriority() + "]");
+		MyThread thread = new MyThread();
+		thread.setName("线程A");
+		thread.start();
+		System.out.println("线程[" + Thread.currentThread().getName() + "]创建线程[" + thread.getName() + "]");
+		System.out.println("main 结束");
+	}
+}
+</code>
+输出
+<code>
+===线程优先级常量=开始======
+线程优先级MIN_PRIORITY=1
+线程优先级NORM_PRIORITY=5
+线程优先级MAX_PRIORITY=10
+===线程优先级常量=结束======
+main 开始
+线程[main]优先级[默认][5]
+=========
+线程[main]优先级[设置][11]
+设置[11]失败!
+线程优先级设置范围在[1]~[10]
+=========
+线程[main]优先级[设置][8]
+线程[main]创建线程[线程A]
+main 结束
+run 开始
+线程[线程A]优先级[继承][8]
+run 结束
+</code>
+  * 优先级的规则性：优先级高的线程大部分先执行完
+  * 优先级的随机性：优先级高的线程不是所有都先执行完
+  * 优先级的速度：优先级高的线程运行速度快
+<code java MyThread.java>
+package com.gxx.threads.study.test13;
+import java.util.Date;
+import java.util.Random;
+/**
+ * 自定义线程类
+ * @author Gxx
+ */
+public class MyThread extends Thread {
+	/**
+	 * 构造方法
+	 * @param name 线程名字
+	 * @param priority 优先级
+	 */
+	public MyThread(String name, int priority) {
+		this.setName(name);//设置线程名字
+		this.setPriority(priority);//设置优先级
+	}
+	/**
+	 * 覆盖run方法
+	 */
+	@Override
+	public void run() {
+		long startTime = new Date().getTime();
+		for(int i=0; i<10000000; i++){
+			new Random().nextInt();
+		}
+		long endTime = new Date().getTime();
+		String name = "[高优先级]";
+		if(this.getPriority() <= 5){
+			name = "[低优先级]";
+		}
+		System.out.println(name + "线程[" + Thread.currentThread().getName() + "]运行结束，耗时[" + (endTime - startTime) + "]毫秒～");
+	}
+}
+</code>
+<code java Test.java>
+package com.gxx.threads.study.test13;
+/**
+ * 测试类－测试线程优先级的规则性，随机性，速度
+ * @author Gxx
+ */
+public class Test {
+	/**
+	 * main方法
+	 * @param args
+	 */
+	public static void main(String[] args) {
+		System.out.println("main 开始");
+		MyThread thread1 = new MyThread("线程1", 10);
+		MyThread thread2 = new MyThread("线程2", 1);
+		MyThread thread3 = new MyThread("线程3", 10);
+		MyThread thread4 = new MyThread("线程4", 1);
+		MyThread thread5 = new MyThread("线程5", 10);
+		MyThread thread6 = new MyThread("线程6", 1);
+		MyThread thread7 = new MyThread("线程7", 10);
+		MyThread thread8 = new MyThread("线程8", 1);
+		MyThread thread9 = new MyThread("线程9", 10);
+		MyThread thread10 = new MyThread("线程10", 1);
+		thread1.start();
+		thread2.start();
+		thread3.start();
+		thread4.start();
+		thread5.start();
+		thread6.start();
+		thread7.start();
+		thread8.start();
+		thread9.start();
+		thread10.start();
+		System.out.println("main 结束");
+	}
+}
+</code>
+输出
+<code>
+main 开始
+main 结束
+[高优先级]线程[线程1]运行结束，耗时[8021]毫秒～
+[高优先级]线程[线程9]运行结束，耗时[8135]毫秒～
+[低优先级]线程[线程6]运行结束，耗时[8168]毫秒～
+[高优先级]线程[线程3]运行结束，耗时[8167]毫秒～
+[低优先级]线程[线程2]运行结束，耗时[8167]毫秒～
+[高优先级]线程[线程7]运行结束，耗时[8174]毫秒～
+[低优先级]线程[线程10]运行结束，耗时[8185]毫秒～
+[低优先级]线程[线程8]运行结束，耗时[8195]毫秒～
+[低优先级]线程[线程4]运行结束，耗时[8198]毫秒～
+[高优先级]线程[线程5]运行结束，耗时[8205]毫秒～
+</code>
+==== 守护线程 ====
+守护线程比如垃圾回收器GC，当没有非守护线程的时候，守护线程没有意义，会自动停止！
+<code java MyThread.java>
+package com.gxx.threads.study.test14;
+/**
+ * 自定义线程类
+ * @author Gxx
+ */
+public class MyThread extends Thread {
+	/**
+	 * 计数
+	 */
+	int count = 0;
+	/**
+	 * 覆盖run方法
+	 */
+	@Override
+	public void run() {
+		while(true){
+			try {
+				Thread.sleep(1000);
+			} catch (InterruptedException e) {
+				e.printStackTrace();
+			}
+			System.out.println("[" + this.getName() + "][守护线程]打印count=" + (++count));
+		}
+	}
+}
+</code>
+<code java Test.java>
+package com.gxx.threads.study.test14;
+/**
+ * 测试类－测试守护线程
+ * @author Gxx
+ */
+public class Test {
+	/**
+	 * main方法
+	 * @param args
+	 */
+	public static void main(String[] args) {
+		System.out.println("[main][非守护线程] 开始");
+		MyThread thread = new MyThread();
+		thread.setName("Thead");
+		System.out.println("[线程][" + thread.getName() + "]默认为" + (thread.isDaemon()?"[true][守护线程]":"[false][非守护线程]"));
+		System.out.println("[线程][" + thread.getName() + "]设置为[true][守护线程]");
+		thread.setDaemon(true);
+		thread.start();
+		try {
+			Thread.sleep(10000);
+		} catch (InterruptedException e) {
+			e.printStackTrace();
+		}
+		System.out.println("[main][非守护线程] 结束，则[守护线程]也自动结束");
+	}
+}
+</code>
+输出
+<code>
+[main][非守护线程] 开始
+[线程][Thead]默认为[false][非守护线程]
+[线程][Thead]设置为[true][守护线程]
+[Thead][守护线程]打印count=1
+[Thead][守护线程]打印count=2
+[Thead][守护线程]打印count=3
+[Thead][守护线程]打印count=4
+[Thead][守护线程]打印count=5
+[Thead][守护线程]打印count=6
+[Thead][守护线程]打印count=7
+[Thead][守护线程]打印count=8
+[Thead][守护线程]打印count=9
+[main][非守护线程] 结束，则[守护线程]也自动结束
+</code>
+===== 对象及变量的并发访问 =====
+==== synchronized同步方法 ====
+=== 方法内变量为线程安全 ===
+<code java NumProcess.java>
+package com.gxx.threads.study.test15;
+/**
+ * 数字处理器
+ * @author Gxx
+ */
+public class NumProcess {
+	/**
+	 * 处理逻辑
+	 */
+	public void process(){
+		System.out.println("[" + Thread.currentThread().getName() + "]进入process~");
+		/**
+		 * 方法内变量
+		 */
+		int num;
+		/**
+		 * 根据线程名称走不同分支
+		 */
+		if(Thread.currentThread().getName().equals("线程A")){
+			num = 100;
+			try {
+				Thread.sleep(2000);//睡眠2秒
+			} catch (InterruptedException e) {
+				e.printStackTrace();
+			}
+		} else {
+			num = 200;
+		}
+		System.out.println("[" + Thread.currentThread().getName() + "] num=" + num);
+	}
+}
+</code>
+<code java MyThead.java>
+package com.gxx.threads.study.test15;
+/**
+ * 自定义线程类
+ * @author Gxx
+ */
+public class MyThread extends Thread {
+	/**
+	 * 数字处理器
+	 */
+	NumProcess numProcess;
+	/**
+	 * 构造方法
+	 * @param name
+	 * @param numProcess
+	 */
+	public MyThread(String name, NumProcess numProcess) {
+		this.setName(name);
+		this.numProcess = numProcess;
+	}
+	/**
+	 * 覆盖run方法
+	 */
+	@Override
+	public void run() {
+		numProcess.process();
+	}
+}
+</code>
+<code java Test.java>
+package com.gxx.threads.study.test15;
+/**
+ * 测试类－测试方法内变量并发访问
+ * @author Gxx
+ */
+public class Test {
+	/**
+	 * main方法
+	 * @param args
+	 */
+	public static void main(String[] args) {
+		System.out.println("main 开始");
+		NumProcess numProcess = new NumProcess();
+		MyThread threadA = new MyThread("线程A", numProcess);
+		MyThread threadB = new MyThread("线程B", numProcess);
+		threadA.start();
+		threadB.start();
+		System.out.println("main 结束");
+	}
+}
+</code>
+输出
+<code>
+main 开始
+main 结束
+[线程A]进入process~
+[线程B]进入process~
+[线程B] num=200
+[线程A] num=100
+</code>
+=== 实例变量非线程安全 ===
+<code java NumProcess.java>
+package com.gxx.threads.study.test16;
+/**
+ * 数字处理器
+ * @author Gxx
+ */
+public class NumProcess {
+	/**
+	 * 实例变量
+	 */
+	int num;
+	/**
+	 * 处理逻辑
+	 */
+	public void process(){
+		System.out.println("[" + Thread.currentThread().getName() + "]进入process~");
+		/**
+		 * 根据线程名称走不同分支
+		 */
+		if(Thread.currentThread().getName().equals("线程A")){
+			num = 100;
+			try {
+				Thread.sleep(2000);//睡眠2秒
+			} catch (InterruptedException e) {
+				e.printStackTrace();
+			}
+		} else {
+			num = 200;
+		}
+		System.out.println("[" + Thread.currentThread().getName() + "] num=" + num);
+	}
+}
+</code>
+<code java MyThead.java>
+package com.gxx.threads.study.test16;
+/**
+ * 自定义线程类
+ * @author Gxx
+ */
+public class MyThread extends Thread {
+	/**
+	 * 数字处理器
+	 */
+	NumProcess numProcess;
+	/**
+	 * 构造方法
+	 * @param name
+	 * @param numProcess
+	 */
+	public MyThread(String name, NumProcess numProcess) {
+		this.setName(name);
+		this.numProcess = numProcess;
+	}
+	/**
+	 * 覆盖run方法
+	 */
+	@Override
+	public void run() {
+		numProcess.process();
+	}
+}
+</code>
+<code java Test.java>
+package com.gxx.threads.study.test16;
+/**
+ * 测试类－测试实例变量并发访问
+ * @author Gxx
+ */
+public class Test {
+	/**
+	 * main方法
+	 * @param args
+	 */
+	public static void main(String[] args) {
+		System.out.println("main 开始");
+		NumProcess numProcess = new NumProcess();
+		MyThread threadA = new MyThread("线程A", numProcess);
+		MyThread threadB = new MyThread("线程B", numProcess);
+		threadA.start();
+		threadB.start();
+		System.out.println("main 结束");
+	}
+}
+</code>
+输出
+<code>
+main 开始
+main 结束
+[线程A]进入process~
+[线程B]进入process~
+[线程B] num=200
+[线程A] num=200
+</code>
+=== 实例变量非线程安全，synchronized同步 ===
+<code java NumProcess.java>
+package com.gxx.threads.study.test17;
+/**
+ * 数字处理器
+ * @author Gxx
+ */
+public class NumProcess {
+	/**
+	 * 实例变量
+	 */
+	int num;
+	/**
+	 * 处理逻辑
+	 */
+	public synchronized void process(){
+		System.out.println("[" + Thread.currentThread().getName() + "]进入process~");
+		/**
+		 * 根据线程名称走不同分支
+		 */
+		if(Thread.currentThread().getName().equals("线程A")){
+			num = 100;
+			try {
+				Thread.sleep(2000);//睡眠2秒
+			} catch (InterruptedException e) {
+				e.printStackTrace();
+			}
+		} else {
+			num = 200;
+		}
+		System.out.println("[" + Thread.currentThread().getName() + "] num=" + num);
+	}
+}
+</code>
+<code java MyThead.java>
+package com.gxx.threads.study.test17;
+/**
+ * 自定义线程类
+ * @author Gxx
+ */
+public class MyThread extends Thread {
+	/**
+	 * 数字处理器
+	 */
+	NumProcess numProcess;
+	/**
+	 * 构造方法
+	 * @param name
+	 * @param numProcess
+	 */
+	public MyThread(String name, NumProcess numProcess) {
+		this.setName(name);
+		this.numProcess = numProcess;
+	}
+	/**
+	 * 覆盖run方法
+	 */
+	@Override
+	public void run() {
+		numProcess.process();
+	}
+}
+</code>
+<code java Test.java>
+package com.gxx.threads.study.test17;
+/**
+ * 测试类－测试实例变量并发访问，synchronized同步
+ * @author Gxx
+ */
+public class Test {
+	/**
+	 * main方法
+	 * @param args
+	 */
+	public static void main(String[] args) {
+		System.out.println("main 开始");
+		NumProcess numProcess = new NumProcess();
+		MyThread threadA = new MyThread("线程A", numProcess);
+		MyThread threadB = new MyThread("线程B", numProcess);
+		threadA.start();
+		threadB.start();
+		System.out.println("main 结束");
+	}
+}
+</code>
+输出
+<code>
+main 开始
+main 结束
+[线程A]进入process~
+[线程A] num=100
+[线程B]进入process~
+[线程B] num=200
+</code>
+=== 多个对象多个锁 ===
+<code java NumProcess.java>
+package com.gxx.threads.study.test18;
+/**
+ * 数字处理器
+ * @author Gxx
+ */
+public class NumProcess {
+	/**
+	 * 实例变量
+	 */
+	int num;
+	/**
+	 * 处理逻辑
+	 */
+	public synchronized void process(){
+		System.out.println("[" + Thread.currentThread().getName() + "]进入process~");
+		/**
+		 * 根据线程名称走不同分支
+		 */
+		if(Thread.currentThread().getName().equals("线程A")){
+			num = 100;
+			try {
+				Thread.sleep(2000);//睡眠2秒
+			} catch (InterruptedException e) {
+				e.printStackTrace();
+			}
+		} else {
+			num = 200;
+		}
+		System.out.println("[" + Thread.currentThread().getName() + "] num=" + num);
+	}
+}
+</code>
+<code java MyThead.java>
+package com.gxx.threads.study.test18;
+/**
+ * 自定义线程类
+ * @author Gxx
+ */
+public class MyThread extends Thread {
+	/**
+	 * 数字处理器
+	 */
+	NumProcess numProcess;
+	/**
+	 * 构造方法
+	 * @param name
+	 * @param numProcess
+	 */
+	public MyThread(String name, NumProcess numProcess) {
+		this.setName(name);
+		this.numProcess = numProcess;
+	}
+	/**
+	 * 覆盖run方法
+	 */
+	@Override
+	public void run() {
+		numProcess.process();
+	}
+}
+</code>
+<code java Test.java>
+package com.gxx.threads.study.test18;
+/**
+ * 测试类－测试多个对象多个锁
+ * @author Gxx
+ */
+public class Test {
+	/**
+	 * main方法
+	 * @param args
+	 */
+	public static void main(String[] args) {
+		System.out.println("main 开始");
+		NumProcess numProcess1 = new NumProcess();
+		MyThread threadA = new MyThread("线程A", numProcess1);
+		NumProcess numProcess2 = new NumProcess();
+		MyThread threadB = new MyThread("线程B", numProcess2);
+		threadA.start();
+		threadB.start();
+		System.out.println("main 结束");
+	}
+}
+</code>
+输出
+<code>
+main 开始
+main 结束
+[线程A]进入process~
+[线程B]进入process~
+[线程B] num=200
+[线程A] num=100
+</code>
+=== synchronized方法与锁对象 ===
+  * 线程进synchronized方法获取锁，都是锁对象实例，其他线程可以进该实例其他不带synchronized的方法
+<code java MethodProcess.java>
+package com.gxx.threads.study.test19;
+/**
+ * 方法处理器
+ * @author Gxx
+ */
+public class MethodProcess {
+	/**
+	 * 方法A
+	 */
+	public synchronized void methodA(){
+		System.out.println("[" + Thread.currentThread().getName() + "]进入methodA~");
+		try {
+			Thread.sleep(2000);
+		} catch (InterruptedException e) {
+			e.printStackTrace();
+		}
+		System.out.println("[" + Thread.currentThread().getName() + "]methodA结束");
+	}
+	/**
+	 * 方法B
+	 */
+	public void methodB(){
+		System.out.println("[" + Thread.currentThread().getName() + "]进入methodB~");
+		System.out.println("[" + Thread.currentThread().getName() + "]methodB结束");
+	}
+}
+</code>
+<code java MyThead.java>
+package com.gxx.threads.study.test19;
+/**
+ * 自定义线程类
+ * @author Gxx
+ */
+public class MyThread extends Thread {
+	/**
+	 * 方法处理器
+	 */
+	MethodProcess methodProcess;
+	/**
+	 * 构造方法
+	 * @param name
+	 * @param methodProcess
+	 */
+	public MyThread(String name, MethodProcess methodProcess) {
+		this.setName(name);
+		this.methodProcess = methodProcess;
+	}
+	/**
+	 * 覆盖run方法
+	 */
+	@Override
+	public void run() {
+		if("线程A".equals(this.getName())){
+			methodProcess.methodA();
+		} else {
+			methodProcess.methodB();
+		}
+	}
+}
+</code>
+<code java Test.java>
+package com.gxx.threads.study.test19;
+/**
+ * 测试类－测试synchronized方法与锁对象
+ * @author Gxx
+ */
+public class Test {
+	/**
+	 * main方法
+	 * @param args
+	 */
+	public static void main(String[] args) {
+		System.out.println("main 开始");
+		MethodProcess methodProcess = new MethodProcess();
+		MyThread threadA = new MyThread("线程A", methodProcess);
+		MyThread threadB = new MyThread("线程B", methodProcess);
+		threadA.start();
+		threadB.start();
+		System.out.println("main 结束");
+	}
+}
+</code>
+输出
+<code>
+main 开始
+main 结束
+[线程A]进入methodA~
+[线程B]进入methodB~
+[线程B]methodB结束
+[线程A]methodA结束
+</code>
+  * 线程A进synchronized的方法A，获取了锁，同时，线程B想进synchronized的方法B，得排队
+<code java MethodProcess.java>
+package com.gxx.threads.study.test20;
+/**
+ * 方法处理器
+ * @author Gxx
+ */
+public class MethodProcess {
+	/**
+	 * 方法A
+	 */
+	public synchronized void methodA(){
+		System.out.println("[" + Thread.currentThread().getName() + "]进入methodA~");
+		try {
+			Thread.sleep(2000);
+		} catch (InterruptedException e) {
+			e.printStackTrace();
+		}
+		System.out.println("[" + Thread.currentThread().getName() + "]methodA结束");
+	}
+	/**
+	 * 方法B
+	 */
+	public synchronized void methodB(){
+		System.out.println("[" + Thread.currentThread().getName() + "]进入methodB~");
+		System.out.println("[" + Thread.currentThread().getName() + "]methodB结束");
+	}
+}
+</code>
+<code java MyThead.java>
+package com.gxx.threads.study.test20;
+/**
+ * 自定义线程类
+ * @author Gxx
+ */
+public class MyThread extends Thread {
+	/**
+	 * 方法处理器
+	 */
+	MethodProcess methodProcess;
+	/**
+	 * 构造方法
+	 * @param name
+	 * @param methodProcess
+	 */
+	public MyThread(String name, MethodProcess methodProcess) {
+		this.setName(name);
+		this.methodProcess = methodProcess;
+	}
+	/**
+	 * 覆盖run方法
+	 */
+	@Override
+	public void run() {
+		if("线程A".equals(this.getName())){
+			methodProcess.methodA();
+		} else {
+			methodProcess.methodB();
+		}
+	}
+}
+</code>
+<code java Test.java>
+package com.gxx.threads.study.test20;
+/**
+ * 测试类－测试synchronized方法与锁对象
+ * @author Gxx
+ */
+public class Test {
+	/**
+	 * main方法
+	 * @param args
+	 */
+	public static void main(String[] args) {
+		System.out.println("main 开始");
+		MethodProcess methodProcess = new MethodProcess();
+		MyThread threadA = new MyThread("线程A", methodProcess);
+		MyThread threadB = new MyThread("线程B", methodProcess);
+		threadA.start();
+		threadB.start();
+		System.out.println("main 结束");
+	}
+}
+</code>
+输出
+<code>
+main 开始
+main 结束
+[线程A]进入methodA~
+[线程A]methodA结束
+[线程B]进入methodB~
+[线程B]methodB结束
+</code>
+=== synchronized锁重入与异常释放锁 ===
+  * 当前类中不同synchronized方法可以锁重入
+  * 父子类中不同synchronized方法可以锁重入
+  * 发生异常，立刻释放锁
+<code java MethodProcess.java>
+package com.gxx.threads.study.test21;
+/**
+ * 方法处理器
+ * @author Gxx
+ */
+public class MethodProcess extends MethodProcessParent {
+	/**
+	 * 方法A
+	 */
+	public synchronized void methodA(){
+		System.out.println("[" + Thread.currentThread().getName() + "]进入methodA~");
+		methodB();
+	}
+	/**
+	 * 方法B
+	 */
+	public synchronized void methodB(){
+		System.out.println("[" + Thread.currentThread().getName() + "]进入methodB~");
+		methodC();
+	}
+	/**
+	 * 方法C
+	 */
+	public synchronized void methodC(){
+		System.out.println("[" + Thread.currentThread().getName() + "]进入methodC~");
+		super.methodD();
+	}
+}
+</code>
+<code java MethodProcessParent.java>
+package com.gxx.threads.study.test21;
+/**
+ * 方法处理器
+ * @author Gxx
+ */
+public class MethodProcessParent {
+	/**
+	 * 计数
+	 */
+	int count = 0;
+	/**
+	 * 方法D
+	 */
+	public synchronized void methodD(){
+		System.out.println("[" + Thread.currentThread().getName() + "]进入methodD~");
+		while (true) {
+			System.out.println("[" + Thread.currentThread().getName() + "]打印count=" + count);
+			try {
+				Thread.sleep(1000);
+			} catch (InterruptedException e) {
+				e.printStackTrace();
+			}
+			if(++count == 5){
+				count = 0;
+				throw new RuntimeException("手动抛出异常~");
+			}
+		}
+	}
+}
+</code>
+<code java MyThead.java>
+package com.gxx.threads.study.test21;
+/**
+ * 自定义线程类
+ * @author Gxx
+ */
+public class MyThread extends Thread {
+	/**
+	 * 方法处理器
+	 */
+	MethodProcess methodProcess;
+	/**
+	 * 构造方法
+	 * @param name
+	 * @param methodProcess
+	 */
+	public MyThread(String name, MethodProcess methodProcess) {
+		this.setName(name);
+		this.methodProcess = methodProcess;
+	}
+	/**
+	 * 覆盖run方法
+	 */
+	@Override
+	public void run() {
+		methodProcess.methodA();
+	}
+}
+</code>
+<code java Test.java>
+package com.gxx.threads.study.test21;
+/**
+ * 测试类－测试synchronized锁重入
+ * @author Gxx
+ */
+public class Test {
+	/**
+	 * main方法
+	 * @param args
+	 */
+	public static void main(String[] args) {
+		System.out.println("main 开始");
+		MethodProcess methodProcess = new MethodProcess();
+		MyThread threadA = new MyThread("线程A", methodProcess);
+		threadA.start();
+		MyThread threadB = new MyThread("线程B", methodProcess);
+		threadB.start();
+		System.out.println("main 结束");
+	}
+}
+</code>
+输出
+<code>
+main 开始
+main 结束
+[线程A]进入methodA~
+[线程A]进入methodB~
+[线程A]进入methodC~
+[线程A]进入methodD~
+[线程A]打印count=0
+[线程A]打印count=1
+[线程A]打印count=2
+[线程A]打印count=3
+[线程A]打印count=4
+[线程B]进入methodA~
+Exception in thread "线程A" java.lang.RuntimeException: 手动抛出异常~
+	at com.gxx.threads.study.test21.MethodProcessParent.methodD(MethodProcessParent.java:27)
+	at com.gxx.threads.study.test21.MethodProcess.methodC(MethodProcess.java:29)
+	at com.gxx.threads.study.test21.MethodProcess.methodB(MethodProcess.java:21)
+	at com.gxx.threads.study.test21.MethodProcess.methodA(MethodProcess.java:13)
+	at com.gxx.threads.study.test21.MyThread.run(MyThread.java:28)
+[线程B]进入methodB~
+[线程B]进入methodC~
+[线程B]进入methodD~
+[线程B]打印count=0
+[线程B]打印count=1
+[线程B]打印count=2
+[线程B]打印count=3
+[线程B]打印count=4
+Exception in thread "线程B" java.lang.RuntimeException: 手动抛出异常~
+	at com.gxx.threads.study.test21.MethodProcessParent.methodD(MethodProcessParent.java:27)
+	at com.gxx.threads.study.test21.MethodProcess.methodC(MethodProcess.java:29)
+	at com.gxx.threads.study.test21.MethodProcess.methodB(MethodProcess.java:21)
+	at com.gxx.threads.study.test21.MethodProcess.methodA(MethodProcess.java:13)
+	at com.gxx.threads.study.test21.MyThread.run(MyThread.java:28)
+</code>
+=== 同步不具有继承性 ===
+<code java MethodProcess.java>
+package com.gxx.threads.study.test22;
+/**
+ * 方法处理器
+ * @author Gxx
+ */
+public class MethodProcess extends MethodProcessParent {
+	/**
+	 * 处理
+	 */
+	public void process(){
+		System.out.println("[" + Thread.currentThread().getName() + "]进入process~");
+		try {
+			Thread.sleep(2000);
+		} catch (InterruptedException e) {
+			e.printStackTrace();
+		}
+		System.out.println("[" + Thread.currentThread().getName() + "]process结束");
+	}
+}
+</code>
+<code java MethodProcessParent.java>
+package com.gxx.threads.study.test22;
+/**
+ * 方法处理器
+ * @author Gxx
+ */
+public class MethodProcessParent {
+	/**
+	 * 处理
+	 */
+	public synchronized void process(){
+		System.out.println("[" + Thread.currentThread().getName() + "]进入process~");
+		try {
+			Thread.sleep(2000);
+		} catch (InterruptedException e) {
+			e.printStackTrace();
+		}
+		System.out.println("[" + Thread.currentThread().getName() + "]process结束");
+	}
+}
+</code>
+<code java MyThead.java>
+package com.gxx.threads.study.test22;
+/**
+ * 自定义线程类
+ * @author Gxx
+ */
+public class MyThread extends Thread {
+	/**
+	 * 方法处理器
+	 */
+	MethodProcess methodProcess;
+	/**
+	 * 构造方法
+	 * @param name
+	 * @param methodProcess
+	 */
+	public MyThread(String name, MethodProcess methodProcess) {
+		this.setName(name);
+		this.methodProcess = methodProcess;
+	}
+	/**
+	 * 覆盖run方法
+	 */
+	@Override
+	public void run() {
+		methodProcess.process();
+	}
+}
+</code>
+<code java Test.java>
+package com.gxx.threads.study.test22;
+/**
+ * 测试类－测试同步不具有继承性
+ * @author Gxx
+ */
+public class Test {
+	/**
+	 * main方法
+	 * @param args
+	 */
+	public static void main(String[] args) {
+		System.out.println("main 开始");
+		MethodProcess methodProcess = new MethodProcess();
+		MyThread threadA = new MyThread("线程A", methodProcess);
+		MyThread threadB = new MyThread("线程B", methodProcess);
+		threadA.start();
+		threadB.start();
+		System.out.println("main 结束");
+	}
+}
+</code>
+输出
+<code>
+main 开始
+main 结束
+[线程B]进入process~
+[线程A]进入process~
+[线程B]process结束
+[线程A]process结束
 </code>

wiki

用户工具

站点工具

差别

页面工具