郁闷我的Thread还是锁不住，请大家帮忙看看

Question

public class LockThread {
public static  void main(String []a){
Thread t1 = new Thread(new M1());
Thread t2 = new Thread(new M2());

t1.start();
t2.start();
    }  public synchronized static void p1(){
System.out.println("P1");
}
public synchronized static void p2(){
System.out.println("P2");
}

public static void p(Object o){
System.out.println(o);
}
}class M1 implements Runnable{
 
public void run() {
LockThread.p1();
try {
Thread.sleep(100);
} catch (InterruptedException e) {}

LockThread.p2();
}
}class M2 implements Runnable{
public void run() {
LockThread.p2();
try {
Thread.sleep(100);
} catch (InterruptedException e) {}

LockThread.p1();
}
}

Answer 1

你这个肯定锁不住的，当执行LockThread.p1()的时候，获取了LockThread本身的锁，但是打印出P1，执行完后就释放了，所以根本不会存在死锁。给你写个例子吧。public class LockThread
{
static Object m_lock1 = new Object();
static Object m_lock2 = new Object();

public static void main(String[] a)
{
Thread t1 = new Thread(new M1());
Thread t2 = new Thread(new M2()); t1.start();
t2.start();
}


static class M1 implements Runnable
{ public void run()
{
synchronized (m_lock1)
{
try
{
Thread.sleep(100);
} 
catch (InterruptedException e)
{
e.printStackTrace();
}

synchronized (m_lock2)
{
System.out.println("p1");
}

}
}
} static class M2 implements Runnable
{ public void run()
{
synchronized (m_lock2)
{
try
{
Thread.sleep(100);
} 
catch (InterruptedException e)
{
e.printStackTrace();
}

synchronized (m_lock1)
{
System.out.println("p2");
}

}
}
}

}

Answer 2

这样啊，我这样写过，不过引用object对象不是你这样直接用的，
我是 LockThread.m_lock1 和LockThread.m_lock2，难怪锁不住。锁到底是锁的什么，是对象吧

Answer 3

synchronized
　　synchronized 关键字，它包括两种用法：synchronized 方法和 synchronized 块。
　　1. synchronized 方法：通过在方法声明中加入 synchronized关键字来声明 synchronized 方法。如：
　　public synchronized void accessVal(int newVal);
　　synchronized 方法控制对类成员变量的访问：每个类实例对应一把锁，每个 synchronized 方法都必须获得调用该方法的类实例的锁方能执行，否则所属线程阻塞，方法一旦执行，就独占该锁，直到从该方法返回时才将锁释放，此后被阻塞的线程方能获得该锁，重新进入可执行状态。这种机制确保了同一时刻对于每一个类实例，其所有声明为 synchronized 的成员函数中至多只有一个处于可执行状态（因为至多只有一个能够获得该类实例对应的锁），从而有效避免了类成员变量的访问冲突（只要所有可能访问类成员变量的方法均被声明为 synchronized）。
　　在 Java 中，不光是类实例，每一个类也对应一把锁，这样我们也可将类的静态成员函数声明为 synchronized ，以控制其对类的静态成员变量的访问。
　　synchronized 方法的缺陷：若将一个大的方法声明为synchronized 将会大大影响效率，典型地，若将线程类的方法 run() 声明为 synchronized ，由于在线程的整个生命期内它一直在运行，因此将导致它对本类任何 synchronized 方法的调用都永远不会成功。当然我们可以通过将访问类成员变量的代码放到专门的方法中，将其声明为 synchronized ，并在主方法中调用来解决这一问题，但是 Java 为我们提供了更好的解决办法，那就是 synchronized 块。
　　2. synchronized 块：通过 synchronized关键字来声明synchronized 块。语法如下：
　　synchronized(syncObject) {
　　//允许访问控制的代码
　　}
　　　　synchronized 块是这样一个代码块，其中的代码必须获得对象 syncObject （如前所述，可以是类实例或类）的锁方能执行，具体机制同前所述。由于可以针对任意代码块，且可任意指定上锁的对象，故灵活性较高。
　　对synchronized(this)的一些理解
　　一、当两个并发线程访问同一个对象object中的这个synchronized(this)同步代码块时，一个时间内只能有一个线程得到执行。另一个线程必须等待当前线程执行完这个代码块以后才能执行该代码块。
　　二、然而，当一个线程访问object的一个synchronized(this)同步代码块时，另一个线程仍然可以访问该object中的非synchronized(this)同步代码块。
　　三、尤其关键的是，当一个线程访问object的一个synchronized(this)同步代码块时，其他线程对object中所有其它synchronized(this)同步代码块的访问将被阻塞。
　　四、第三个例子同样适用其它同步代码块。也就是说，当一个线程访问object的一个synchronized(this)同步代码块时，它就获得了这个object的对象锁。结果，其它线程对该object对象所有同步代码部分的访问都被暂时阻塞。
　　五、以上规则对其它对象锁同样适用 

Answer 4

谁帮我改改package ThreadTest;public class LockThread
{
    static Object o1 = new Object();
    static Object o2 = new Object();
    
    public static void main(String[] a)
    {
     Question s = new Question();
        Thread t1 = new Thread(new M1(s));
        Thread t2 = new Thread(new M2(s));        t1.start();
        t2.start();
    }
    
    static void p(Object o){
     System.out.println(o);
    }}class Question{
int index=0;
    synchronized void P1(int i){
     this.index=i;
    }    synchronized void P2(int i){
     this.index=i;
    }
}class M1 implements Runnable{
Question l1;
public M1(Question l1){
this.l1=l1;
} public void run() {
l1.P1(1); try {
Thread.sleep(100);
} catch (InterruptedException e) {}

l1.P2(7);
}

}
class M2 implements Runnable{
Question l2;
public M2(Question l2){
this.l2=l2;
}

public void run() {
l2.P2(7);

try {
Thread.sleep(100);
} catch (InterruptedException e) {}

l2.P1(4);
}

}

Answer 5

public class LockThread { public static void main(String[] a) {
Question s = new Question();
Question s2 = new Question();
Thread t1 = new Thread(new M1(s, s2));
Thread t2 = new Thread(new M2(s, s2)); t1.start();
t2.start();
} static void p(Object o) {
System.out.println(o);
}}class Question {
int index = 0; void P1(int i) {
this.index = i;
} void P2(int i) {
this.index = i;
}
}class M1 implements Runnable {
Question l1;
Question l2; public M1(Question l1, Question l2) {
this.l1 = l1;
this.l2 = l2;
} public void run() {
synchronized (l1) {
System.out.println("M1-l1"); try {
Thread.sleep(100);
} catch (InterruptedException e) {
}
synchronized (l2) {
System.out.println("M1-l2");
}
}
}}class M2 implements Runnable {
Question l1;
Question l2; public M2(Question l1, Question l2) {
this.l1 = l1;
this.l2 = l2;
} public void run() {
synchronized (l2) {
System.out.println("M2-l2"); try {
Thread.sleep(100);
} catch (InterruptedException e) {
}
synchronized (l1) {
System.out.println("M2-l1");
}
}
}
}