使用extends Thread方法实现的多线程如何同步

Question

RT。
使用extends Thread方法实现的多线程，如何保证synchronized的方法和代码块同步呢？
我们知道，synchronized修饰的方法的同步监视器对象是this，但是我们启动多个线程时，这个this对象不一样。
使用synchronized修饰的方法要想和代码块使用同一个监视器对象的话，这个监视器对象该是什么呢？

Answer 1

用synchronized修饰的方法  如果是非静态 那么是在 本对象， 也就是 this 上同步synchronized 修饰代码块 ，  要 synchronized（this）  在同一个对象上同步跟你 实现runnable  还是继承thread 没关系

Answer 2

nchronized修饰的方法的同步监视器对象是this，但是我们启动多个线程时，这个this对象不一样。这个不一定  ，如果你所有线程都驱动同一个任务的实例  ,那么就在这个实例上同步，如果每个线程驱动的是不同任务的实例 那么不需要同步

Answer 3

我表示你的表示在我的预料之中。
是这样的。以下这段代码无法达到同步的效果，虽然method方法使用了synchronized修饰，但他们的监视器对象不同，是吧？那么如何让这四个对象（t1、t2、t3、t4）使用同一个监视器来达到同步效果呢？
class Thread2 extends Thread {
int n = 100; public void run() {
method();
} public synchronized void method() {
while (n > 0) {
System.out.println(n--);
} }
}
class Test { public static void main(String[] args) {
Thread2 t1 = new Thread2();
Thread2 t2 = new Thread2();
Thread2 t3 = new Thread2();
Thread2 t4 = new Thread2();
t1.start();
t2.start();
t3.start();
t4.start(); }
}

Answer 4

public static void method(){}//方法的话,就加上static
synchronized(thisClass.class){//synchronized块的话就是该对象类的字节码
}

Answer 5

for exampleclass SomeThread extends Thread {
    Object locker;
    public SomeThread(Object locker) {
        this.locker = locker;
    }
    public void run() {
        synchronized(locker) { //locker共同访问的资源就可以了
            //do something here
        }
    }
}public class Test {
    public static void main(String[] args) {
        Object locker = new Object();
        Thread[] t = new Thread[10];
        for (int i=0; i<t.length; i++) {
            t[i] = new SomeThread(locker); //把共同资源对象传给线程
              t[i].start();
        }
    }
}
只要锁住共同访问的资源对象就可以了，如果想偷懒，直接synchronized(SomeThread.class)，锁住类对象，不过锁类对象牺牲太大，性能有所下降，所以轻易不锁类对象。

Answer 6

哥们 你仔细找本书看看吧。。        Thread2 t1 = new Thread2();
        Thread2 t2 = new Thread2();
        Thread2 t3 = new Thread2();
        Thread2 t4 = new Thread2();你自己new 了4个任务 你同步什么？？？先弄清楚什么是线程啊  继承了 Thread 只能说明这是一个可以被线程驱动的任务， 线程是用来驱动任务的啊。。
你自己new了四个任务  有用四个线程分别驱动四个任务互不干涉啊，因为四个线程有各自的栈啊，谁和谁同步 ？？？？？

Answer 7

我貌似 能看明白你的意思了  你是说 这样？
          Thread temp=new Thread2();         
  
         Thread2 t1 = temp;
        Thread2 t2 = temp;
        Thread2 t3 = temp;
        Thread2 t4 = temp;是这个意思吧？？？？

Answer 8

1、这种方法很容易理解，只要所有线程使用同一个监视器对象，那么他们就可以实现同步。
2、这儿的synchronized修饰的是代码块，我们可以直接定义监视器（locker），但假如这儿还有一个synchronized修饰的方法呢？这个方法和代码块如何同步呢？代码块使用了locker，而方法使用了this。当然单纯从解决问题的角度可能没这么复杂，但在这儿我想明白就是这种情况下该怎么同步呢？
3、Object.class 好像所有的类都有这个class方法，但我没找到这个方法是属于那个类，也查不到源码，这个方法该如何理解呢？
谢谢~
汗~~

Answer 9

你的话太长了class 是 Class 的实例，每个类都有一个与之对应的 Class 的实例， 这个实例的创建是虚拟机完成的，你可以看看 Class类 的源码

Answer 10

1
就是这样
2
如果你要修饰方法，原理一样
for example
class SomeClass implements Runnable {
    synchronized void somemethod() {
    }    public void run() {
        somemethod();
    }
}
public class Test {
    public static void main(String[] args) {
        SomeClass sc = new SomeClass();
        Thread[] t = new Thread[10];
        for (int i=0; i<t.length; i++) {
            t[i] = new Thread(sc); //多个线程共同使用sc，调用sc的synchronized方法
              t[i].start();
        }
    }
}
3
你只需要知道xxx.class返回xxx类的类对象就可以了，就好像知道数组对象.length返回数组的长度一样，不要关心源码具体如何实现

Answer 11

恩，这种情况下就必须使用implements Runnable方式，而使用extends Thread方式，就不可以了吧

Answer 12

一样的，Thread本身就是impelments Runnable的
你把代码改成如下是一样的效果
class SomeClass extends Thread {
    synchronized void somemethod() {
    }    public void run() {
        somemethod();
    }
}
public class Test {
    public static void main(String[] args) {
        SomeClass sc = new SomeClass();
        Thread[] t = new Thread[10];
        for (int i=0; i<t.length; i++) {
            t[i] = new Thread(sc); //多个线程共同使用sc，调用sc的synchronized方法
              t[i].start();
        }
    }
}
多个线程共同使用一个sc对象，所以sc没有必要一定要继承Thread

Answer 13

我也在学多线程, 自己理解 是同步到object, 而不是方法，也不是this等等玩意.  
object具有唯一的key， 任何线程来访问他里面的 synchronized method()，synchronized(this) {   }代码段等, 都是经过object进来的, 谁拿到了key，谁就进来执行，完了交出key；没拿到key又要进来的，就慢慢等呗