一 、多线程同步的背景
- 多线程环境中，可能会有两个或更多个的线程试图同时访问一个有限的资源。必须对这种潜在的资源冲突进行预防。
- 解决办法：在线程使用一个资源时为其加锁即可。访问资源的第一个线程为其加上锁以后，其他线程不能再使用那个资源，除非被解锁。
二、多线程同步的实现
1、对于访问某个关键共享资源的所有方法，都必须把他们设为synchronized。例如：
public synchronized void f() {...}
public synchronized void g() {...}
2、synchronized 关键字
当用synchronized关键字秀是一个方法时，该方法叫做同步方法
3、Java中的每个对象都有一个锁（lock）或者叫做监听器（monitor）。当访问某个对象的synchronized方法时，就会将该对象上锁，此时其它任何线程都无法再去访问该synchronized方法了，直到之前的那个线程执行方法完毕后或是抛出异常，该对象的锁才会被解开，其它线程才有可能去访问synchronized方法。FetchMoney例子说明：
/**
* 如果想保护某些资源不被多个线程同时访问，可以强制通过synchronized方法访问那些资源。
* 调用synchronized方法时，对象就会被锁定。
* @author Chuan
*
*/
public class FetchMoney
{
public static void main(String[] args)
{
Bank bank = new Bank();
MoneyThread t1 = new MoneyThread(bank);
MoneyThread t2 = new MoneyThread(bank);
t1.start();
t2.start();
}
}
class Bank
{
private int money = 1000;
public synchronized int getMoney(int number)
{
if (number < 0)
{
return -1;
}
else if (number > money)
{
return -2;
}
else if (money < 0)
{
return -3;
}
try
{
Thread.sleep(1000);
}
catch (InterruptedException e)
{
// TODO Auto-generated catch block
e.printStackTrace();
}
money -= number;
System.out.println("left money:" + money);
return number;
}
}
class MoneyThread extends Thread
{
private Bank bank;
public MoneyThread(Bank bank)
{
this.bank = bank;
}
@Override
public void run()
{
System.out.println(bank.getMoney(800));
}
}
程序运行结果如下：
image.png
4、如果一个对象有多个synchronized方法，某一时刻某个线程已经进入到了某个synchronized方法，那么在该方法没有执行完毕前，其他线程是无法访问该对象的任何synchronized方法的。ThreadTest4例子说明：
/**
* 如果一个对象有多个synchronized方法，某一时刻某个线程已经进入到了某个synchronized方法，
* 那么在该方法没有执行完毕前，其他线程是无法访问该对象的任何synchronized方法的。
* @author Chuan
*
*/
public class ThreadTest4
{
public static void main(String[] args)
{
Example example = new Example();
ThreadFirst t1 = new ThreadFirst(example);
ThreadSecond t2 = new ThreadSecond(example);
t1.start();
t2.start();
}
}
class Example
{
public synchronized void execute()
{
for (int i = 0; i < 10; i++)
{
try
{
Thread.sleep((long)(Math.random() * 1000));
}
catch (InterruptedException e)
{
e.printStackTrace();
}
System.out.println("hello " + i);
}
}
public synchronized void execute2()
{
for (int i = 0; i < 10; i++)
{
try
{
Thread.sleep((long)(Math.random() * 1000));
}
catch (InterruptedException e)
{
e.printStackTrace();
}
System.out.println("world " + i);
}
}
}
class ThreadFirst extends Thread
{
private Example example;
public ThreadFirst(Example example)
{
this.example = example;
}
@Override
public void run()
{
example.execute();
}
}
class ThreadSecond extends Thread
{
private Example example;
public ThreadSecond(Example example)
{
this.example = example;
}
@Override
public void run()
{
example.execute2();
}
}
程序运行结果如下：
image.png
5、如果synchronized方法是static的,那么当线程访问该方法时，它锁的并不是synchronized所在的对象，而好似synchronized方法所在对象所对应的Class对象。因为Java中无论一个类有多少个对象，这些对象都会对应唯一一个Class对象，因此当线程分别访问一个类的两个对象的static、synchronized方法时，它们的执行顺序也是顺序的，也就是一个线程先去执行方法，执行完毕后另一个线程才开始执行。ThreadTest5例子说明：
/**
* 如果某个synchronized方法是static的，那么当线程访问该方法时，
* 它锁的并不是synchronized方法所在的对象，而是synchronized方法所在的对象所对应的Class对象，
* 因为Java中无论一个类有多少个对象，这些对象会对应唯一一个Class对象，
* 因此当线程分别访问同一个类的两个对象的两个static，synchronized方法时，
* 他们的执行顺序也是顺序的，也就是说一个线程先去执行方法，执行完毕后另一个线程才开始执行。
* @author Chuan
*
*/
public class ThreadTest5
{
public static void main(String[] args)
{
Example2 example = new Example2();
ThreadFirst2 t1 = new ThreadFirst2(example);
example = new Example2();
ThreadSecond2 t2 = new ThreadSecond2(example);
t1.start();
t2.start();
}
}
class Example2
{
public synchronized static void execute()
{
for (int i = 0; i < 10; i++)
{
try
{
Thread.sleep((long)(Math.random() * 1000));
}
catch (InterruptedException e)
{
e.printStackTrace();
}
System.out.println("hello " + i);
}
}
public synchronized static void execute2()
{
for (int i = 0; i < 10; i++)
{
try
{
Thread.sleep((long)(Math.random() * 1000));
}
catch (InterruptedException e)
{
e.printStackTrace();
}
System.out.println("world " + i);
}
}
}
class ThreadFirst2 extends Thread
{
private Example2 example;
public ThreadFirst2(Example2 example)
{
this.example = example;
}
@Override
public void run()
{
this.example.execute();
}
}
class ThreadSecond2 extends Thread
{
private Example2 example;
public ThreadSecond2(Example2 example)
{
this.example = example;
}
@Override
public void run()
{
this.example.execute2();
}
}
程序运行结果如下：
image.png
6、synchronized块，写法;
private Object object = new Object();
synchronized(object)
{
...
}
表示线程在执行的时候会对object对象上锁。ThreadTest6例子shuoming
public class ThreadTest6
{
public static void main(String[] args)
{
Example3 example = new Example3();
ThreadFirst3 t1 = new ThreadFirst3(example);
ThreadSecond3 t2 = new ThreadSecond3(example);
t1.start();
t2.start();
}
}
class Example3
{
private Object object = new Object();
public void execute()
{
synchronized(object)
{
for (int i = 0; i < 10; i++)
{
try
{
Thread.sleep((long)(Math.random() * 1000));
}
catch (InterruptedException e)
{
e.printStackTrace();
}
System.out.println("hello " + i);
}
}
}
public void execute2()
{
synchronized(object)
{
for (int i = 0; i < 10; i++)
{
try
{
Thread.sleep((long)(Math.random() * 1000));
}
catch (InterruptedException e)
{
e.printStackTrace();
}
System.out.println("world " + i);
}
}
}
}
class ThreadFirst3 extends Thread
{
private Example3 example;
public ThreadFirst3(Example3 example)
{
this.example = example;
}
@Override
public void run()
{
example.execute();
}
}
class ThreadSecond3 extends Thread
{
private Example3 example;
public ThreadSecond3(Example3 example)
{
this.example = example;
}
@Override
public void run()
{
example.execute2();
}
}
程序硬性结果如下：
image.png
7、synchronized方法是一种粗粒度的并发控制，某一时刻只能有一个线程执行该synchronized方法；synchronized块是一种细粒度的并发控制，只会将块中的代码同步，位于方法内，synchronized块之外的代码是可以被多个线程同时访问的。
8、同步的线程状态图
image.png
9 、线程的相互作用
- 线程的相互作用主要涉及到两个方法：wait()和notify()，这两个方法是定义在Object类中的，而且是final的。因此会被所有的Java类继承但是无法重写。这两个方法要求在调用时线程已经获得了对象的锁，因此对这两个方法的调用需要放在synchronized方法或块中。当线程执行了wait方法时，它会释放掉对象的锁。
- 线程的相互作用主要涉及到两个pool：wait poll 和lock pool。
-
具有wait()和notify()的线程状态图：
image.png - 看一个同步的综合例题：Sample类里有一个整型变量number（初始值为0），两个方法increase() 加1和decrease()减1。另外有一个线程IncreaseThread调用加1方法，还有一个线程DecreaseThread调用减1方法。最终结果是实现0 1 0 1 0 1...的变更。
（1）首先实现Sample类。
其中increase()和decrease方法都是suynchronized修饰的，即同步方法。每个方法中都调用了wait()和notify()方法，以实现不同线程间的相互作用。需要注意的是，wait()方法会释放锁，并让线程在此位置停止执行，直到该线程获得锁以及系统资源，就会继续从此为止向下执行。因此紧跟wait()方法后仍需要判断条件是否满足。这也是下面程序中采用while循环判断，而不用if判断的原因。
public class Sample
{
private int number;
public synchronized void increase()
{
//每次做事情前都要判断条件是否满足
while (number != 0)
{
try
{
//wait会释放锁，并且停在此处.当获得通知后，继续向下执行
//此处需要在等待结束后继续判断是否满足条件，因为其他线程可能在等待期间已经进行了操作
wait();
}
catch (InterruptedException e)
{
e.printStackTrace();
}
}
number++;
System.out.println(number);
notify();
}
public synchronized void decrease()
{
//每次做事情前都要判断条件是否满足
while (number == 0)
{
try
{
wait();
}
catch (InterruptedException e)
{
e.printStackTrace();
}
}
number--;
System.out.println(number);
notify();
}
}
（2）调用加1方法的IncreaseThread线程
public class IncreaseThread extends Thread
{
private Sample sample;
public IncreaseThread(Sample sample)
{
this.sample = sample;
}
@Override
public void run()
{
for(int i = 0; i < 10; i++)
{
try
{
Thread.sleep((long)(Math.random() * 1000));
}
catch (InterruptedException e)
{
e.printStackTrace();
}
this.sample.increase();
}
}
}
(3)调用减1方法的DecreaseThread线程
public class DecreaseThread extends Thread
{
private Sample sample;
public DecreaseThread(Sample sample)
{
this.sample = sample;
}
@Override
public void run()
{
for(int i = 0; i < 10; i++)
{
try
{
Thread.sleep((long)(Math.random() * 1000));
}
catch (InterruptedException e)
{
e.printStackTrace();
}
this.sample.decrease();
}
}
}
(4)MainTest主程序进行测试
public class MainTest
{
public static void main(String[] args)
{
Sample sample = new Sample();
IncreaseThread t1 = new IncreaseThread(sample);
DecreaseThread t2 = new DecreaseThread(sample);
IncreaseThread t3 = new IncreaseThread(sample);
DecreaseThread t4 = new DecreaseThread(sample);
t1.start();
t2.start();
t3.start();
t4.start();
}
}
（6）MainTest的运行结果
image.png
10、另一个会导致线程暂停的方法就是Thread类的sleep方法，它会导致线程暂停指定的毫秒数，但线程在睡眠的过程中不会释放掉对象的锁。