Java多线程：多线程的Synchronized详解

输出为什么要引入同步机制

在多线程环境中，可能会有两个甚至更多的线程试图同时访问一个有限的资源。必须对这种潜在资源冲突进行预防。
解决方法：在线程使用一个资源时为其加锁即可。访问资源的第一个线程为其加上锁以后，其他线程便不能再使用那个资源，除非被解锁。

怎样实现同步

对于访问某个关键共享资源的所有方法，都必须把它们设为synchronized
例如：
synchronized void f() { /* ... */ } synchronized void g() { /* ... */ }
如果想保护某些资源不被多个线程同时访问，可以强制通过synchronized方法访问那些资源。 调用synchronized方法时，对象就会被锁定。

public class MyStack {
    int idx = 0;
    char [] data = new char[ 6];
    public synchronized void push( char c) {
 　　   data[ idx] = c;
  　　  idx++;
    }
    public synchronized char pop() {
    　　idx--;
   　　 return data[ idx];
    }
}

说明：
•当synchronized方法执行完或发生异常时，会自动释放锁。
•被synchronized保护的数据应该是私有（private）的。

看几个例子

public class ThreadTest3
{
    public static void main(String[] args)
    {
        Runnable r = new HelloThread();
        
        Thread t1 = new Thread(r);
        
        //r = new HelloThread();
        
        Thread t2 = new Thread(r);
        
        t1.start();
        t2.start();
    }
}

class HelloThread implements Runnable
{
    int i;
    
    @Override
    public void run()
    {
    //    int i = 0;
        
        while(true)
        {
            System.out.println("number: " + i++);
            
            try
            {
                Thread.sleep((long)(Math.random() * 1000));
            }
            catch (InterruptedException e)
            {
                e.printStackTrace();
            }
            
            if(5 == i)
            {
                break;
            }
        }
    }
}

输出顺序执行：

程序执行时出现了两种输出，现在分别来分析一下：

为什么打印两个0：如文章开头所讲，由于两个线程同时访问一个资源，而且此资源未加锁就会导致访问冲突。

线程1打印语句还未执行++操作，线程2就进来了，所以导致打印两个0

为什么"只有一个线程输出"：

只打印了0-4，给人感觉只打印了一条线程，其实这是两条线程共同作用的结果。

因为 i 这个变量是一个成员变量，而在同一个对象 r 中成员变量是共享的，当线程对 i 进行++操作，线程2中的 i 也会更改，所以打印出这样的结果

如果将 i 放在方法内即变成局部变量，则会打印两条线程的执行结果

总结：

关于成员变量与局部变量：如果一个变量是成员变量，那么多个线程对同一个对象的成员变量进行操作时，他们对该成员变量是彼此影响的（也就是说一个线程对成员变量的改变会影响到另一个线程）。
如果一个变量是局部变量，那么每个线程都会有一个该局部变量的拷贝，一个线程对该局部变量的改变不会影响到其他的线程。
停止线程的方式：不能使用Thread类的stop方法来终止线程的执行。一般要设定一个变量，在run方法中是一个循环，循环每次检查该变量，如果满足条件则继续执行，否则跳出循环，线程结束。

synchronized关键字

synchronized关键字：当synchronized关键字修饰一个方法的时候，该方法叫做同步方法。
Java中的每个对象都有一个锁（lock）或者叫做监视器（monitor），当访问某个对象的synchronized方法时，表示将该对象上锁，此时其他任何线程都无法再去访问该synchronized方法了，直到之前的那个线程执行方法完毕后（或者是抛出了异常），那么将该对象的锁释放掉，其他线程才有可能再去访问该synchronized方法。

public class ThreadTest4
{
    public static void main(String[] args)
    {
        Example example = new Example();
        
        Thread t1 = new TheThread(example);
        
        example = new Example();
        
        Thread t2 = new TheThread2(example);
        
        t1.start();
        t2.start();
    }
}

class Example
{
    public synchronized void execute()
    {
        for(int i = 0; i < 5; 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 < 5; i++)
        {
            try
            {
                Thread.sleep((long)(Math.random() * 1000));
            }
            catch (InterruptedException e)
            {
                e.printStackTrace();
            }
            
            System.out.println("world: " + i);
        }
    }
}

class TheThread extends Thread
{
    private Example example;
    
    public TheThread(Example example)
    {    
        this.example = example;
    }
    
    @Override
    public void run()
    {
        this.example.execute();
    }
}

class TheThread2 extends Thread
{
    private Example example;
    
    public TheThread2(Example example)
    {    
        this.example = example;
    }
    
    @Override
    public void run()
    {
        this.example.execute2();
    }
}

结果为

结果可以看出两条线程都同时执行了且互不影响。

当我们修改main方法

public class ThreadTest4
{
    public static void main(String[] args)
    {
        Example example = new Example();
        
        Thread t1 = new TheThread(example);
        
        Thread t2 = new TheThread2(example);
        
        t1.start();
        t2.start();
    }
}

使用同一个 example，结果为

这个结果是必然的，不管你执行多少次。

很显然，线程在执行时是一个线程一个线程的执行的。

原因就如上面红字所讲的，当访问某个对象的synchronized方法时表示对该对象上锁，我们这里使用的是同一个example对象，所以只能等上一个线程执行完后才能执行下一个线程，而不能同时执行。

如果一个对象有多个synchronized方法，某一时刻某个线程已经进入到了某个synchronized方法，那么在该方法没有执行完毕前，其他线程是无法访问该对象的任何synchronized方法的。

再来更改Example对象，在其方法上都加上 static 修饰

public synchronized static void execute()
    {
        for(int i = 0; i < 5; 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 < 5; i++)
        {
            try
            {
                Thread.sleep((long)(Math.random() * 1000));
            }
            catch (InterruptedException e)
            {
                e.printStackTrace();
            }
            
            System.out.println("world: " + i);
        }
    }

这时，不管你是否使用同一个example，执行结果都是先执行线程1在执行线程2.

原因就在于：

如果某个synchronized方法是static的，那么当线程访问该方法时，它锁的并不是synchronized方法所在的对象，而是synchronized方法所在的对象所对应的Class对象，因为Java中无论一个类有多少个对象，这些对象会对应唯一一个Class对象，因此当线程分别访问同一个类的两个对象的两个static，synchronized方法时，他们的执行顺序也是顺序的，也就是说一个线程先去执行方法，执行完毕后另一个线程才开始执行。

再对Example方法进行修改，改成一个static一个非static

    public synchronized void execute()
    {
        for(int i = 0; i < 5; 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 < 5; i++)
        {
            try
            {
                Thread.sleep((long)(Math.random() * 1000));
            }
            catch (InterruptedException e)
            {
                e.printStackTrace();
            }
            
            System.out.println("world: " + i);
        }
    }

这时不管你是否使用同一个example，结果都是乱序，即两个线程同时执行，原因还是在于锁对象问题。

static锁的是class对象，非static锁的就是对象，两个锁的对象不同，结果自然不同。

synchronized代码块

synchronized方法是一种粗粒度的并发控制，某一时刻，只能有一个线程执行该synchronized方法;

synchronized块则是一种细粒度的并发控制，只会将块中的代码同步，位于方法内、synchronized块之外的代码是可以被多个线程同时访问到的。

所以更多情况下，我们选择把需要同步的逻辑写在synchronized块中。

synchronized(object)
{
      。。。          
}

表示线程在执行的时候会对object对象上锁

所以上面的程序就可以改为

public void execute()
    {
        synchronized (this)
        {
            for (int i = 0; i < 20; i++)
            {
                try
                {
                    Thread.sleep((long) (Math.random() * 1000));
                }
                catch (InterruptedException e)
                {
                    e.printStackTrace();
                }

                System.out.println("hello: " + i);
            }
        }

    }

    public void execute2()
    {
        synchronized(Example.class)
        {
            for (int i = 0; i < 20; i++)
            {
                try
                {
                    Thread.sleep((long) (Math.random() * 1000));
                }
                catch (InterruptedException e)
                {
                    e.printStackTrace();
                }

                System.out.println("world: " + i);
            }
        }    
    }