线程问题

Question

public class Letters extends Thread {
private String name;

public Letters(String name) {
this.name = name;
}

public void write() {
System.out.print(name);
System.out.print(name);
}

public static void main(String[]args) {
new Letters("X").start();
new Letters("Y").start();
}

/*
public void run() {
synchronized (Letters.class) {
write();
}
}
*/

public void run() {
synchronized (System.out) {
write();
}
}
}
2个run都可以输出xxyy或者yyxx，可是Letters.class，System.out这2个为什么这样写不大懂。

Answer 1

注释掉的那个是锁住当前的对象,System.out是锁住输出对象.

Answer 2

锁住当前对象的话写this为什么不对？

Answer 3

new Letters("X")
new Letters("Y")是2个对象， this则分别代表他们这2个
也就是
第一个对象运行时，this是代表第一个的，和第二个没有任何关系

Answer 4

这个synchronized (Letters.class)对你的程序没有任何的作用
，不会有任何的影响。锁住了该类的class对象只会使得静态方法同步，如果你的write是静态方法的话，会起到同步作用。
而synchronized (System.out)就起到了同步的作用，因为你的write函数是用到了System.out对象
括号里边是谁，就同步谁

Answer 5

大家不要理解错了，注释掉的是锁住该类的class对象，会使得该类的静态方法同步执行，在这里并没有起到任何的作用。因为你的write方法并不是静态的。

Answer 6

虽然说创建了两个对象，但是system.out只有一个

Answer 7

注释掉的那个run我理解错了，应该是这样理解：
虽然创建了两个对象，但是一旦进入    public void run() {
        synchronized (Letters.class) {
            write();
        }
    }
就拥有了Letters类的Class对象的对象锁，因为对于每个类的class对象只有一个，所以，也实现了同步。

Answer 8

总结一下：
创建了两个线程对象，用两种不同的方法实现了同步
第一个是通过唯一的Letters.class类对象；
第二个是通过唯一的System.out对象；

Answer 9

两个同步对象在这里的控制范围是完全一样的。同步System.out只能使代码混乱，叫怪招百出。什么时候应该使用自定义对象锁？即多个对象的相同操作需要同步，而不同操作不需要同步。
例子：class A{
    m1(){}
    m2(){}
}现在我有两个实例 a1,a2；
a1.m1()调用时，a2.m1()不能调用，但a1.m2()或a2.m2()可以操作，如果我有A.class作为同步对象，则
a1.m1()调用时，a2.m1()，a1.m2()，a2.m2()都不可以操作，因为它们要获取同一个锁。
所以我定义两个对局对象，分别用于多个实例的m1()和m2(),但m1()和m2()之间不发生互斥。用什么样的对象同步就是控制什么范围内的同步问题。

Answer 10

控制一个类的静态的方法同步时，使用class对象挺好，
控制一个类的对象同步的时候，还是用对象锁,Synchronized关键字

Answer 11

顺带说下，你在十二楼的回复：

所以我定义两个对局对象，分别用于多个实例的m1()和m2(),但m1()和m2()之间不发生互斥。 

这句不是很明白，你能不能举个例子，期待你的回复。

Answer 12

java.lang.Class   妈的没有构造方法   害的我好惨~~~~  

Answer 13

没有什么难的，就是利用了两个唯一的对象
一个是Letters.class对象；
一个是System.out对象；
实现了两个Letters实例对象的同步。
Letters x输出的时候
Letters y等着，等Letters x输出结束，再输出Y，就这些。