多线程简单实例（1）真的需要synchronized么？

说道多线程的安全问题，很多人想到就就是加锁。用到synchronized关键字。

那就要先说说synchronized问什么能够保证线程安全了。

首先要了解线程的工作方式：线程工作分为工作内存和主内存。主内存就是堆和静态区。当线程运行时，首先将主内存的数据拿到工作内存

然后在工作内存中运行，再将数据写回主内存。工作内存是私有的，但是主内存却是共享的。

那么线程不安全的主要根源就是不能线程读写主内存的共享数据。

那么判断要不要加锁，在什么位置加锁就有了依据——共享数据

下面看一个例子：

package code.thread;

public class SynchronizedDome extends Thread{
    int a = 0;
    Object obj = new Object();
    @Override
    public void run() {
        synchronized(obj) {
            for(int i=5;i>0;i--){
                System.out.println(a);
                a++;
                try {
                    Thread.sleep(0);
                } catch (InterruptedException e) {
                    // TODO Auto-generated catch block
                    e.printStackTrace();
                }
            }
        }
    }
    
    public static void main(String[] args) {
        SynchronizedDome dome = new SynchronizedDome();
        SynchronizedDome dome2 = new SynchronizedDome();
        SynchronizedDome dome3 = new SynchronizedDome();
        System.out.println("Thread start:");
        dome.start();
        dome2.start();
        dome3.start();
    }
}

执行结果：

Thread start:
0
1
0
0
2
3
1
1
2
3
4
4
2
3
4

看到没，并没有发生错乱，与预想的输出结果一致

那么你可能会说，这是synchronized的功劳。真的是这样的么，稍微改动过一下在看看

package code.thread;

public class SynchronizedDome extends Thread{
    int a = 0;
    Object obj = new Object();
    @Override
    public void run() {
        //synchronized(obj) {
        {
            for(int i=5;i>0;i--){
                System.out.println(a);
                a++;
                try {
                    Thread.sleep(0);
                } catch (InterruptedException e) {
                    // TODO Auto-generated catch block
                    e.printStackTrace();
                }
            }
        }
    }
    
    public static void main(String[] args) {
        SynchronizedDome dome = new SynchronizedDome();
        SynchronizedDome dome2 = new SynchronizedDome();
        SynchronizedDome dome3 = new SynchronizedDome();
        System.out.println("Thread start:");
        dome.start();
        dome2.start();
        dome3.start();
    }
}

看到没，还是安全的，并没有因为没加锁而发生错乱

那么我没就要分析一下了，根据我们上面所说的，线程的不安全是因为数据的共享

这个例子中，分别new了三个线程对象。

每个对象在栈上有一个变量a，他们分别属于不同的对象。所以三个线程操作的都是属于自己本身类的数据。是对象私有的。

所以不存在数据的共享，那么就不用加锁了。

我没在看一个例子，让他们数据共享，将变量定义为静态变量

package code.thread;

public class SynchronizedDome2 {
    public static void main(String[] args) {
        Dome dome = new Dome();
        Thread thread = new Thread(dome);
        Thread thread2 = new Thread(dome);
        
        thread.start();
        thread2.start();
        
    }
}

class Dome implements Runnable {
    static int a = 0;
    @Override
    public void run() {
        //synchronized(this){
        {
            for(int i=0;i<5;i++) {
                System.out.println(Thread.currentThread().getName()+":  "+a++);
            }
        }
    }
}

输出结果：

Thread-1: 0
Thread-0: 1
Thread-1: 2
Thread-0: 3
Thread-1: 4
Thread-0: 5
Thread-1: 6
Thread-1: 8
Thread-0: 7
Thread-0: 9

这么换乱，而且我们侥幸没有得到错误的结果。如果多运行几次就会看到可能会出现错误的结果

那么下面用锁来解决，看看有什么不同。

程序就是将什么代码加锁注释去掉。

输出结果：

Thread-0: 0
Thread-0: 1
Thread-0: 2
Thread-0: 3
Thread-0: 4
Thread-1: 5
Thread-1: 6
Thread-1: 7
Thread-1: 8
Thread-1: 9

总结：总的来说线程不安全是由于共享数据的读写不同步引起的。当不涉及到共享数据，也就无不安全可说了。

synchronized关键字保证了操作的原子性和可见性。原子性就是说，一个执行步奏完整的执行完毕，不会再执行的过程中被其他线程打断。

可见性是说，当执行完锁定的代码块后，在解锁之前会把最新的数据写入到主内存中。并且清空其他线程工作内存中该数据的值。保证了该数据时最新的。