1 public class MySynchronized extends Thread2 {3     private int val;4     5     private static Object lock = new Object();6     7     public MySynchronized(int v)8     {9         val = v;
10     }
11
12     public void printVal(int v)
13     {
14         synchronized (lock)
15         {
16             while (true)
17             {
18                 System.out.println(v);
19             }
20         }
21     }
22
23     public void run()
24     {
25         printVal(val);
26     }
27 }

1 public class MySynchronized extends Thread2 {3     private int val;4     5     public MySynchronized(int v)6     {7         val = v;8     }9
10     public void printVal(int v)
11     {
12         synchronized (MySynchronized.class)
13         {
14             while (true)
15             {
16                 System.out.println(v);
17             }
18         }
19     }
20
21     public void run()
22     {
23         printVal(val);
24     }
25 }

public class MySynchronized extends Thread
{private String name;private String val;public MySynchronized(String name, String v){this.name = name;val = v;}public void printVal(){synchronized (val){while (true){System.out.println(name + val);}}}public void run(){printVal();}public static void main(String args[]){MySynchronized f1 = new MySynchronized("Foo 1:", "printVal");f1.start();MySynchronized f2 = new MySynchronized("Foo 2:", "printVal");f2.start();}
}

/* *  非静态方法: *  给对象加锁(可以理解为给这个对象的内存上锁,注意 只是这块内存,其他同类对象都会有各自的内存锁),这时候 * 在其他一个以上线程中执行该对象的这个同步方法(注意:是该对象)就会产生互斥 *  静态方法:  * 相当于在类上加锁(*.class 位于代码区,静态方法位于静态区域,这个类产生的对象公用这个静态方法,所以这块 * 内存，N个对象来竞争), 这时候,只要是这个类产生的对象,在调用这个静态方法时都会产生互斥 */