线程学习笔记【3】---互斥技术

第一个示例更多的是运用了内部类的特性：

内部类重要特点：可以访问外部的成员变量，所以内部类不能在静态方法中实例化。

因为静态方法运行时不需要创建实例对象，而内部类想要访问成员变量，意味着外部类肯定要创建实例对象，二者相互矛盾。

所以下面就会报错

public class Synchronized01 {

	public static void main(String args[]) {
）
		// final Outputer outputer=new Outputer(); //这样做就没有成员变量可以访问
		// new Thread(new Runnable(){
		//
		// public void run() {
		// while(true){
		// try {
		// Thread.sleep(10);
		// } catch (InterruptedException e) {
		// e.printStackTrace();
		// }
		// outputer.outputer("zhangsan");
		// }
		// }}).start();
	}
class Outputer {
		void outputer(String name) {
			int len = name.length();
			for (int i = 0; i < len; i++) {
				System.out.print(name.charAt(i));
			}
			System.out.println();
		}
	}
}

但如果改成这样就没有问题

public class Synchronized01 {

	public static void main(String args[]) {	
             new Synchronized01().init();
	}
         // 此方法被调用时一定创建了外部类对象
         private void init() {

                        // 运行时找外部类对象，找调用init方法的对象
		final Outputer outputer = new Outputer(); 	

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

			public void run() {
				while (true) {
					try {
						Thread.sleep(10);
					} catch (InterruptedException e) {
						e.printStackTrace();
					}
					outputer.outputer("lisi");
				}
			}
		}).start();
	}

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

运行结果

        lisi zhangsan lisi zhangsan lisi zhangsan lisi zhangsan lisi zhangsan
        lisi zhangsan lisi zhangsan lisi zhanlgissain
        zlhiasnig san lzihsain gsan zlhiasnig san zlhiasnig san zlhiasnig san
        zlhiasnigsan zlhiasnig san lzihsain gsan lisi zhangsan lisi

解决方法

修改Ouputer

class Outputer {
		public void outputer(String name) {
			int len = name.length();
			synchronized (this) {// 两个线程用的是同一个outputer对象
				for (int i = 0; i < len; i++) {
					System.out.print(name.charAt(i));
				}
				System.out.println();
			}
		}

		// synchronized要在void之前
		// 一个方法只能有一个synchronized，不然可能会造成死锁
		public synchronized void outputer2(String name) {
			int len = name.length();
			for (int i = 0; i < len; i++) {
				System.out.print(name.charAt(i));
			}
			System.out.println();
		}

	}
	// class Outputer {
	// String xxx = "";
	//
	// public void outputer(String name) {
	// int len = name.length();

             // xxx必须是同一个对象，如果是name就仍然会出错 name是两个对象
	// synchronized (xxx) { 	

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

 

但如果每个run()中这样写new Outputer()然后调用outputer(name)仍然会出错，因为每次new都是产生一个新的对象，而synchronized关键是针对同一个对象。

public class Synchronized02 {

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

	private void init() {
		final Outputer outputer = new Outputer();
		new Thread(new Runnable() {

			public void run() { // 要执行的操作
				while (true) { // 循环操作
					try {
						Thread.sleep(10);
					} catch (InterruptedException e) {
						e.printStackTrace();
					}
					outputer.outputer("zhangsan");
				}
			}
		}).start();
		new Thread(new Runnable() {

			public void run() {
				while (true) {
					try {
						Thread.sleep(10);
					} catch (InterruptedException e) {
						e.printStackTrace();
					}
					outputer.outputer("lisi");

                                                    //这样仍然会出问题 ----不是同一个对象。
				// new Outputer().outputer("lisi"); 				}
			}
		}).start();

	}

	class Outputer {
		public void outputer(String name) {
			int len = name.length();
			synchronized (this) {// 两个线程用的是同一个outputer对象
				for (int i = 0; i < len; i++) {
					System.out.print(name.charAt(i));
				}
				System.out.println();
			}
		}

		// synchronized要在void之前
		// 一个方法只能有一个synchronized，不然可能会造成死锁
		public synchronized void outputer2(String name) {
			int len = name.length();
			for (int i = 0; i < len; i++) {
				System.out.print(name.charAt(i));
			}
			System.out.println();
		}

	}
	// class Outputer {
	// String xxx = "";
	//
	// public void outputer(String name) {
	// int len = name.length();

        // xxx必须是同一个对象，如果是name就仍然会出错 name是两个对象
	// synchronized (xxx) {	

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

}
一个内部类前面加上static就变成了外部类

静态方法只能在外部类中声明

静态方法只和字节码对象有关

public class Synchronized03 {

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

	private void init() {
		final Outputer outputer = new Outputer();
		new Thread(new Runnable() {

			public void run() { // 要执行的操作
				while (true) { // 循环操作
					try {
						Thread.sleep(10);
					} catch (InterruptedException e) {
						e.printStackTrace();
					}
					outputer.outputer("zhangsan");
				}
			}
		}).start();
		new Thread(new Runnable() {

			public void run() {
				while (true) {
					try {
						Thread.sleep(10);
					} catch (InterruptedException e) {
						e.printStackTrace();
					}
					outputer.outputer2("lisi");
				}
			}
		}).start();

	}

	static class Outputer { // 加上static 相当于是个外部类
		public void outputer(String name) {
			int len = name.length();
            // 静态方法不创建类的实例对象，创建字节码对象,静态方法运行时只和字节码对象关联
		synchronized (Outputer.class) {

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

		// synchronized要在void之前
                         // 静态方法只能在外部类中声明
		public static synchronized void outputer2(String name) { 	

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

	}

}