多线程加锁导致数据不同步问题join方法探究

public class Test {

  public static void main(String[] args) throws InterruptedException {
    Account a = new Account();
    Account b = new Account();
    Account c = new Account();

    for (int i = 0; i < 3000; i++) {
      Thread t1 = new Thread(()->{
        a.transfer(b, 100);
      });
      Thread t2 = new Thread(()->{
        b.transfer(c, 100);
      });

      Thread t3 = new Thread(()->{
        c.transfer(a, 100);
      });

      t1.start();
      t2.start();
      t3.start();
    }

    System.out.println(a.getBalance());
    System.out.println(b.getBalance());
    System.out.println(c.getBalance());
  }
}

class Account {
  private int balance = 200;

  void transfer(Account target, int amount) {
    synchronized (this) {
      synchronized (target) {
        if (this.balance > amount) {
          this.balance -= amount;
          target.balance += amount;
        }
      }
    }
  }

  public int getBalance() {
    return balance;
  }
}

我运行下面的代码为什么结果是随机的，正确情况应该都是200。请老师指正

打印的时候，那三个线程还没执行完，打印前需要join一下那三个线程

分析

public class TestJoin {
 
    public static void main(String[] args) throws InterruptedException {
        // TODO Auto-generated method stub
        ThreadTest t1=new ThreadTest("A");
        ThreadTest t2=new ThreadTest("B");
        t1.start();
        t2.start();
    }
 
 
}
class ThreadTest extends Thread {
    private String name;
    public ThreadTest(String name){
        this.name=name;
    }
    public void run(){
        for(int i=1;i<=5;i++){
                System.out.println(name+"-"+i);
        }        
    }
}
/*运行结果
A-1
B-1
B-2
B-3
A-2
B-4
A-3
B-5
A-4
A-5
可以看出A线程和B线程是交替执行的。
*/

而在其中加入join()方法后(后面的代码都略去了ThreadTest类的定义)

public class TestJoin {
    public static void main(String[] args) throws InterruptedException {
        // TODO Auto-generated method stub
        ThreadTest t1=new ThreadTest("A");
        ThreadTest t2=new ThreadTest("B");
        t1.start();
        t1.join();
        t2.start();
    }
}
/*运行结果：

A-1
A-2
A-3
A-4
A-5
B-1
B-2
B-3
B-4
B-5*/

显然，使用t1.join()之后，B线程需要等A线程执行完毕之后才能执行。需要注意的是，t1.join()需要等t1.start()执行之后执行才有效果，此外，如果t1.join()放在t2.start()之后的话，仍然会是交替执行，然而并不是没有效果，这点困扰了我很久，也没在别的博客里看到过。

这个在Java编程思想并发那一章有详细的解释。首先你的t1.join是在main主线程上调用的，所以只会让main主线程暂时挂起，不会影响到t2线程。这里只要记住，哪个线程挂起，取决于在哪个线程上调用x.join方法，而不是影响到所有的线程
join()方法的底层是利用wait()方法实现的。可以看出，join方法是一个同步方法，当主线程调用t1.join()方法时，主线程先获得了t1对象的锁，随后进入方法，调用了t1对象的wait()方法，使主线程进入了t1对象的等待池，此时，A线程则还在执行，并且随后的t2.start()还没被执行，因此，B线程也还没开始。等到A线程执行完毕之后，主线程继续执行，走到了t2.start()，B线程才会开始执行。

package CSDN;
 
public class TestJoin {
 
    public static void main(String[] args) throws InterruptedException {
        // TODO Auto-generated method stub
        System.out.println(Thread.currentThread().getName()+" start");
        ThreadTest t1=new ThreadTest("A");
        ThreadTest t2=new ThreadTest("B");
        ThreadTest t3=new ThreadTest("C");
        System.out.println("t1start");
        t1.start();
        System.out.println("t2start");
        t2.start();
        System.out.println("t3start");
        t3.start();
        System.out.println(Thread.currentThread().getName()+" end");
    }
 
}

/*
main start
t1start
t1end
t2start
t2end
t3start
t3end
A-1
A-2
main end
C-1
C-2
C-3
C-4
C-5
A-3
B-1
B-2
B-3
B-4
B-5
A-4
A-5
*/

乱序执行

package CSDN;
 
public class TestJoin {
 
    public static void main(String[] args) throws InterruptedException {
        // TODO Auto-generated method stub
        System.out.println(Thread.currentThread().getName()+" start");
        ThreadTest t1=new ThreadTest("A");
        ThreadTest t2=new ThreadTest("B");
        ThreadTest t3=new ThreadTest("C");
        System.out.println("t1start");
        t1.start();
        System.out.println("t1end");
        System.out.println("t2start");
        t2.start();
        System.out.println("t2end");
        t1.join();
        System.out.println("t3start");
        t3.start();
        System.out.println("t3end");
        System.out.println(Thread.currentThread().getName()+" end");
    }
 
}
/*
main start
t1start
t1end
t2start
t2end
A-1
B-1
A-2
A-3
A-4
A-5
B-2
t3start
t3end
B-3
main end
B-4
B-5
C-1
C-2
C-3
C-4
C-5
*/

• 多次实验可以看出，主线程在t1.join()方法处停止，并需要等待A线程执行完毕后才会执行t3.start()，然而，并不影响B线程的执行。因此，可以得出结论，t.join()方法只会使主线程进入等待池并等待t线程执行完毕后才会被唤醒。并不影响同一时刻处在运行状态的其他线程。
• join源码中，只会调用wait方法，并没有在结束时调用notify，这是因为线程在die的时候会自动调用自身的notifyAll方法，来释放所有的资源和锁。
• join() 会让调用线程等待被调用线程结束后，才会继续执行（在此期间其他线程也在运行，也会交替执行，只是被join的线程完成后，才会继续操作主线程）。使用的场景为我们需要等待某个线程执行完成后才可继续执行的场景