使用synchronized实现同步

我们先来看一段代码：

class TicketThread implements Runnable{
    private int ticket = 10;
    @Override
    public void run() {
        while(this.ticket>0){
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println(Thread.currentThread().getName()+"正在为您服务，当前还剩 "+this.ticket--+" 张票");
        }
    }
}

public class TestDemo {
    public static void main(String[] args) {
        TicketThread ticketThread = new TicketThread();
        Thread thread1 = new Thread(ticketThread,"1号售票员");
        Thread thread2 = new Thread(ticketThread,"2号售票员");
        Thread thread3 = new Thread(ticketThread,"3号售票员");
        thread1.start();
        thread2.start();
        thread3.start();
    }
}

结果如下：

可以看到，当前代码出现了负数票的情况，这是因为不同步而导致的。

我们可以使用synchronized关键字来实现同步，实际上也就是加锁操作，使得同一时刻只能有一个线程获取到锁而进入同步代码块中。

使用synchronized关键字处理有两种模式：同步代码块与同步方法。接下来我们分别看一下这两种方式，就以上面的代码为例：

1.同步代码块：
此时我们只需要锁住卖票的对象就可以了，这样同一时刻只能有一个对象拿到锁并卖票

public void run() {
        for(int i = 0;i<10;i++){
            synchronized (this){
                if(this.ticket>0) {
                    try {
                        Thread.sleep(1000);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                    System.out.println(Thread.currentThread().getName()+"正在为您服务，当前还剩 "+this.ticket--+" 张票");
                }
            }
        }
    }

结果如下：

2.同步方法：

class TicketThread implements Runnable{
    private int ticket = 10;
    @Override
    public void run() {
        for(int i = 0;i<10;i++){
            this.sale();
        }
    }
    public synchronized void sale(){
        if(this.ticket>0) {
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println(Thread.currentThread().getName()+"正在为您服务，当前还剩 "+this.ticket--+" 张票");
        }
    }
}

结果如下：

可见，当我们使用同步方法的时候，同一时刻只能有一个线程进入该方法卖票。

我们再来看一段代码：

class Sync{
    public synchronized void test(){
        System.out.println(Thread.currentThread().getName()+"Running");
        try {
            Thread.sleep(1000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println(Thread.currentThread().getName()+"End");
    }
}

class SyncThread implements Runnable{

    @Override
    public void run() {
        Sync sync = new Sync();
        sync.test();
    }

}

public class SyncTest {
    public static void main(String[] args) {
        SyncThread syncThread = new SyncThread();
        for(int i = 1;i<=3;i++){
            new Thread(syncThread,"Thread_"+i).start();
        }
    }
}

结果如下：

我们预期的结果应该是，同一时刻只有一个线程拿到锁进入同步方法，当这个线程释放锁从同步方法出来后，另一个线程才能进入，但此时三个线程都进入了同步方法，这是怎么回事呢？

来看这里：

实际上我们这里每次都创建了一个新对象，而非static同步方法以及synchronized(this)只能防止多个线程同时执行同一对象的同步代码块，即此时锁住的是当前对象；若要锁住一段代码块，则必须使用全局锁，此时锁的是类。处理方法如下：

1.锁同一个对象：

class Sync{
    public void test(){
        synchronized (this){
            System.out.println(Thread.currentThread().getName()+"Running");
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println(Thread.currentThread().getName()+"End");
        }
    }
}

class SyncThread implements Runnable{
    private Sync sync;
    public SyncThread(Sync sync){
        this.sync = sync;
    }

    @Override
    public void run() {
        this.sync.test();
    }
}

public class SyncTest {
    public static void main(String[] args) {
        Sync sync = new Sync();
        SyncThread syncThread = new SyncThread(sync);
        for(int i = 1;i<=3;i++){
            new Thread(syncThread,"Thread_"+i).start();
        }
    }
}

结果如下：

此时我们锁住的就是同一个对象。

2.锁类对象：

class Sync{
    public void test(){
        synchronized (Sync.class){
            System.out.println(Thread.currentThread().getName()+"Running");
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println(Thread.currentThread().getName()+"End");
        }
    }
}

class SyncThread implements Runnable{

    @Override
    public void run() {
        Sync sync = new Sync();
        sync.test();
    }

}

public class SyncTest {
    public static void main(String[] args) {
        SyncThread syncThread = new SyncThread();
        for(int i = 1;i<=3;i++){
            new Thread(syncThread,"Thread_"+i).start();
        }
    }
}

结果如下：

3.使用全局锁：

class Sync{
    public static synchronized void test(){
        System.out.println(Thread.currentThread().getName()+"Running");
        try {
            Thread.sleep(1000); 
        } catch (InterruptedException e) {
            e.printStackTrace(); 
        }
        System.out.println(Thread.currentThread().getName()+"End");
    }
}

结果如下：