Question

我是Java新手。下面是代码作为线程和同步的示例。

public class A implements Runnable{
    public synchronized void run(){

        /*
        some code here
         */

    }
}

public class B {
    public static void main(String[] args){
        A obj1 = new A();
        Thread t = new Thread(obj1);
        A obj2 = obj1;
        Thread t1 = new Thread(obj2);
        t.start();
        t1.start();
    }
}

现在这两个线程会相互阻塞同一个锁，还是会得到两个不同的锁？

谢谢！

Answer 1

（首先，请坚持使用Java编码约定。类名应始终以大写字母开头。没有例外。）

一次只有一个线程会执行run()方法。

A.run()方法是一个实例方法，它被声明为synchronized。这两个事实意味着它将在进入方法体之前获得this（即A的实例）的锁定，并在退出时释放它。简而言之，run()锁定this。

因此，在您的主程序中，您将创建一个A实例并将其作为两个线程的target对象传递。他们都需要在同一个对象上执行run()方法，这不可能同时发生......通过前一段的推理。

这不是必然意味着一个线程将阻止另一个线程。在第二个线程准备好尝试调用之前，第一个要启动的线程也可能已完成其run()调用。但我们可以说...... 明确地 ......两个线程对run()的调用不会及时重叠。

Answer 2

他们会互相阻挡，因为他们在同一个对象上都是synchronized。

例如，这个程序：

public class Foo
{
    public static void main(final String... args)
    {
        final Runnable r =
            new Runnable()
            {
                public synchronized void run()
                {
                    for(int i = 0; i < 10; ++i)
                    {
                        System.out.println(i);
                        try
                            { Thread.sleep(1000L); }
                        catch(final InterruptedException ie)
                            { throw new RuntimeException(ie); }
                    }
                }
            };
        new Thread(r).start();
        new Thread(r).start();
    }
}

将打印0到9，在数字后暂停一秒，然后再次执行。它将不交织两组数字。

Answer 3

同步会强制线程按顺序运行（阻止）。

根据定义，同步意味着“一次一个”运行方法。因此，在第二个线程（可能是“t1”）的run（）方法进入之前，第一个要执行的线程（可能是“t”）将完成。

测试同步效果：

要运行的最佳实验是通过调用

来填充run（）方法

 Thread.sleep(1000);

然后使用，而不使用“synchronized”关键字运行代码，并为程序执行时间。

Answer 4

此代码的输出正在混合thread1和thread0

package oopd;
/**
*
* @author mani deepak
*/
public class Oopd {

/**
 * @param args the command line arguments
 */
public static void main(String[] args) 
{
    // TODO code application logic here
    Deepak d,d1;
    d=new Deepak();
    d1=new Deepak();
    Thread t,t1;
    t=new Thread(d);
    t1=new Thread(d1);
    t.start();
    t1.start();
}
}

class Deepak implements Runnable
{
@Override
public synchronized void run()
{
    String s=Thread.currentThread().getName();
    for(int i=0;i<10;i++)
    {
        try
        {
        Thread.sleep(100);
        }
        catch(Exception e)
        {

        }
        System.out.println(s+" "+i);
    }
}
}

线程和同步示例

4 个答案: