Java多线程-1-线程安全与锁

进程与线程概念回顾

• 进程（Process）

  是计算机中的程序关于某数据集合上的一次运行活动，是系统进行资源分配和调度的基本单位，是操作系统结构的基础。在早期面向进程设计的计算机结构中，进程是程序的基本执行实体；在当代面向线程设计的计算机结构中，进程是线程的容器。程序是指令、数据及其组织形式的描述，进程是程序的实体。

• 线程（Thread）

  有时被称为轻量级进程(Lightweight Process，LWP），是程序执行流的最小单元。线程是程序中一个单一的顺序控制流程。进程内一个相对独立的、可调度的执行单元，是系统独立调度和分派CPU的基本单位指运行中的程序的调度单位。在单个程序中同时运行多个线程完成不同的工作，称为多线程。

• 进程与线程的关系

  一个进程对于1或多道线程。

  

Java实现多线程的方法

• 继承Thread，重写run()方法

  public class MyThread extends Thread {
  
      @Override
      public void run() {
          while (true) {
              System.out.println(currentThread().getName());
          }
      }
  
      public static void main(String[] args) {
          MyThread thread = new MyThread();
          thread.start(); //线程启动的正确方式
      }
  }

  输出结果：

  Thread-0
  Thread-0
  Thread-0
  ...

  要明白，启动线程的是start()方法而不是run()方法，如果用run()方法，那么它就是一个普通的方法被执行了。

• 实现Runnable接口

  public class MyRunnable implements Runnable {
  
      @Override
      public void run() {
          System.out.println("123");
      }
  
      public static void main(String[] args) {
          MyRunnable myRunnable = new MyRunnable();
          Thread thread = new Thread(myRunnable, "t1");
          thread.start();
      }
  }

线程安全

当多个线程访问某一个类（对象或方法）时，这个类始终能表现出正确的行为，那么这个类（对象或方法）就是线程安全的。

线程安全就是多线程访问时，采用了加锁机制，当一个线程访问该类的某个数据时，进行保护，其他线程不能进行访问直到该线程读取完，其他线程才可使用。不会出现数据不一致或者数据污染。 线程不安全就是不提供数据访问保护，有可能出现多个线程先后更改数据造成所得到的数据是脏数据。这里的加锁机制常见的如：synchronized。

锁的原理

Java中每个对象都有一个内置锁。

当程序运行到非静态的synchronized同步方法上时，自动获取与正在执行代码类的当前实例（this实例）有关的锁。获得一个对象的锁也称为获取锁、锁定对象、在对象上锁定或在对象上同步。

当程序运行到synchronized同步方法或代码块时，该对象锁才起作用。

一个对象只有一个锁。所以，如果一个线程获得该锁，就没有其他线程可以获得锁，直到第一个线程释放（或返回）锁。这也意味着任何其他线程都不能进入该对象上的synchronized方法或代码块，直到该锁被释放。

释放锁是指持锁线程退出了synchronized同步方法或代码块。

锁和同步

关于锁和同步，有以下几个要点：

1. 只能同步方法，而不能同步变量和类；

2. 每个对象只有一个锁；当提到同步时，应当清楚在什么上同步？也就是说，在哪个对象上同步。

3. 不必同步类中所有的方法，类可以拥有同步和非同步的方法；

4. 如果两个线程要执行一个类中的synchronized方法，并且两个线程使用相同的实例来调用方法，那么一次只能有一个线程能够执行方法，另一个需要等待，知道锁被释放。也就是说，如果一盒线程在对象上获得一个锁，就没有任何其他线程可以进入（该对象的）类的任何一个同步方法。

5. 线程睡眠时，它所持有的任何人锁都不会被释放；

6. 线程可以获得多个锁。比如，在一个对象的同步方法里面调用另一个对象的同步方法，则获得了两个对象的同步锁；

7. 同步损害并发性，应该尽可能的缩小同步范围。

线程如果不能获取锁会怎么样

如果线程试图进入同步方法，而其锁已经被占用，则线程在该对象上被阻塞。实质上，线程进入该对象的的一种池中，必须在哪里等待，直到其锁被释放，该线程再次变为可运行或运行为止。

当考虑阻塞时，一定要注意哪个对象正被用于锁定：

1. 调用同一个对象中非静态同步方法的线程将彼此阻塞。如果是不同对象，则每个线程有自己的对象的锁，线程间彼此互不干预。
2. 调用同一个类中的静态同步方法的线程将彼此阻塞，它们都是锁定在相同的Class对象上。
3. 静态同步方法和非静态同步方法将永远不会彼此阻塞，因为静态方法锁定在Class对象上，非静态方法锁定在该类的对象上。
4. 对于同步代码块，要看清楚什么对象已经用于锁定（synchronized后面括号的内容）。在同一个对象上进行同步的线程将彼此阻塞，在不同对象上锁定的线程将永远不会彼此阻塞。

synchronized修饰符

可以在任意对象及方法上加锁，而加锁的这段代码称为“互斥区”或“临界区”。

• 当我们不使用synchronized时

  public class MyThread extends Thread {
  
    private int count = 5;
  
    @Override
    public void run() {
        count--;
        System.out.println(currentThread().getName() + " count:" + count);
    }
  
    public static void main(String[] args) {
        MyThread myThread = new MyThread();
        Thread thread1 = new Thread(myThread, "thread1");
        Thread thread2 = new Thread(myThread, "thread2");
        Thread thread3 = new Thread(myThread, "thread3");
        Thread thread4 = new Thread(myThread, "thread4");
        Thread thread5 = new Thread(myThread, "thread5");
        thread1.start();
        thread2.start();
        thread3.start();
        thread4.start();
        thread5.start();
    }
  }

  输出的一种结果为：

  thread1 count:3
  thread4 count:1
  thread2 count:3
  thread3 count:2
  thread5 count:0

  可以看到，上述的结果是不正确的，这是因为，多个线程同时操作run()方法，对count进行修改，进而造成错误。

• 使用synchronized之后

  public class MyThread extends Thread {
  
      private int count = 5;
  
      @Override
      public synchronized void run() {
          count--;
          System.out.println(currentThread().getName() + " count:" + count);
      }
  
      public static void main(String[] args) {
          MyThread myThread = new MyThread();
          Thread thread1 = new Thread(myThread, "thread1");
          Thread thread2 = new Thread(myThread, "thread2");
          Thread thread3 = new Thread(myThread, "thread3");
          Thread thread4 = new Thread(myThread, "thread4");
          Thread thread5 = new Thread(myThread, "thread5");
          thread1.start();
          thread2.start();
          thread3.start();
          thread4.start();
          thread5.start();
      }
  }

  输出的一种结果为：

  thread1 count:4
  thread3 count:3
  thread2 count:2
  thread4 count:1
  thread5 count:0

  可以看出代码A和代码B的区别就是在run()方法上加上了synchronized修饰.

• 说明

  当多个线程访问MyThread 的run()方法的时候，如果使用了synchronized修饰，那个多线程就会以排队的方式进行处理（这里排队是按照CPU分配的先后顺序而定的）。一个线程想要执行synchronized修饰的方法里的代码，首先是尝试获得锁，如果拿到锁，执行synchronized代码体的内容，如果拿不到锁的话，这个线程就会不断的尝试获得这把锁，直到拿到为止，而且多个线程同时去竞争这把锁，也就是会出现锁竞争的问题。

  使用synchronized同步不但可以同步整个方法，还可以同步方法中的一部分代码块；在使用同步代码块的时候，**应该指定在哪个对象上同步，也就是说要获取哪个对象的锁。例如：

  public int fix(int y){
  	synchronized (this) {
  		x = x - y;
  	}
  	return x;
  }

  当然，同步方法也可以改写成非同步方法，但功能完全一样的，例如：

  public synchronized int getX() {
        return x++;
  }

  与

  public int getX() {
        synchronized (this) {
              return x++;
        }
  }

  效果完全一样。

一个对象有一把锁，多个线程有多把锁

首先我们来看一下下面的代码实例：

public class MultiThread {

    private int num = 200;

    public synchronized void printNum(String threadName, String tag) {
        if (tag.equals("a")) {
            num = num - 100;
            System.out.println(threadName + " tag a,set num over!");
        } else {
            num = num - 200;
            System.out.println(threadName + " tag b,set num over!");
        }
        System.out.println(threadName + " tag " + tag + ", num = " + num);
    }

    public static void main(String[] args) throws InterruptedException {
        final MultiThread multiThread1 = new MultiThread();
        final MultiThread multiThread2 = new MultiThread();

        new Thread(new Runnable() {
            public void run() {
                multiThread1.printNum("thread1", "a");
            }
        }).start();
		 
        new Thread(new Runnable() {
            public void run() {
                multiThread2.printNum("thread2", "b");
            }
        }).start();
    }
}

输出结果：

thread1 tag a,set num over!
thread1 tag a, num = 100
thread2 tag b,set num over!
thread2 tag b, num = 0

可以看出，有两个对象：multiThread1和multiThread2，如果多个对象使用同一把锁的话，那么上述执行的结果就应该是：thread2 tag b, num = -100，因此，是每一个对象拥有该对象的锁的。

关键字synchronized取得的锁都是对象锁，而不是把一段代码或方法当做锁，所以上述实例代码中哪个线程先执行synchronized 关键字的方法，那个线程就持有该方法所属对象的锁，两个对象，线程获得的就是两个不同对象的不同的锁，他们互不影响的。

那么，我们在正常的场景的时候，肯定是有一种情况的就是，所有的对象会对一个变量count进行操作，那么如何实现哪？很简单就是加static，我们知道，用static修改的方法或者变量，在该类的所有对象是具有相同的引用的，这样的话，无论实例化多少对象，调用的都是一个方法，代码如下：

public class MultiThread {

    private static int num = 200;

    public static synchronized void printNum(String threadName, String tag) {
        if (tag.equals("a")) {
            num = num - 100;
            System.out.println(threadName + " tag a,set num over!");
        } else {
            num = num - 200;
            System.out.println(threadName + " tag b,set num over!");
        }
        System.out.println(threadName + " tag " + tag + ", num = " + num);
    }

    public static void main(String[] args) throws InterruptedException {
        final MultiThread multiThread1 = new MultiThread();
        final MultiThread multiThread2 = new MultiThread();

        new Thread(new Runnable() {
            public void run() {
                multiThread1.printNum("thread1", "a");
            }
        }).start();

        Thread.sleep(5000);
        System.out.println("等待5秒，确保thread1已经执行完毕！");	 
        
        new Thread(new Runnable() {
            public void run() {
                multiThread2.printNum("thread2", "b");
            }
        }).start();
    }
}

输出结果如下：

thread1 tag a,set num over!
thread1 tag a, num = 100
等待5秒，确保thread1已经执行完毕！
thread2 tag b,set num over!
thread2 tag b, num = -100

可以看出，对变量和方法都加上了static修饰，就可以实现我们所需要的场景，同时也说明了，对于非静态static修饰的方法或变量，是一个对象一把锁的。

对象锁的同步和异步

1. 同步：synchronized

   同步的概念就是”共享”，我们要知道“共享”这两个字，如果不是共享的资源，就没有必要进行同步，也就是没有必要进行加锁；

   同步的目的就是为了线程的安全，其实对于线程的安全，需要满足两个最基本的特性：原子性和可见性。

   原子性指线程已经是最小单位，不可再拆封；

   可见性是指一个线程对共享变量值的修改，能够及时的被其他线程看到（详见链接3）。

2. 异步：asynchronized

   异步的概念就是独立，相互之间不受到任何制约，两者之间没有任何关系。

   示例：

   public class MyObject {
   
       public void method() {
           System.out.println(Thread.currentThread().getName());
       }
   
       public static void main(String[] args) {
           final MyObject myObject = new MyObject();
   
           Thread t1 = new Thread(new Runnable() {
               public void run() {
                   myObject.method();
               }
           }, "t1");
   
           Thread t2 = new Thread(new Runnable() {
               public void run() {
                   myObject.method();
               }
           }, "t2");
   
           t1.start();
           t2.start();
       }
   }

   上述代码中，method()方法就是异步的。

何时需要同步

在多个线程同时访问互斥（可交换）数据时，应该同步以加以保护数据，确保两个线程不会同时秀给更改它。

对于非静态字段中可更改的数据，通常使用非静态的方法访问。

对于静态字段中可更改的数据，通常使用静态方法访问。

如果需要在非静态方法中使用静态字段，或者在静态字段中调用非静态方法，问题将变得非常复杂。

小结

1. 线程同步的目的是为了保护多个线程访问一个资源时对资源的破坏。
2. 线程同步方法是通过锁来实现，每个对象都有切仅有一个锁，这个锁与一个特定的对象关联，线程一旦获取了对象锁，其他访问该对象的线程就无法再访问该对象的其他同步方法。
3. 对于静态同步方法，锁是针对这个类的，锁对象是该类的Class对象。静态和非静态方法的锁互不干预。一个线程获得锁，当在一个同步方法中访问另外对象上的同步方法时，会获取这两个对象锁。
4. 对于同步，要时刻清醒在哪个对象上同步，这是关键。
5. 编写线程安全的类，需要时刻注意对多个线程竞争访问资源的逻辑和安全做出正确的判断，对“原子”操作做出分析，并保证原子操作期间别的线程无法访问竞争资源。
6. 当多个线程等待一个对象锁时，没有获取到锁的线程将发生阻塞。
7. 死锁是线程间相互等待锁锁造成的，在实际中发生的概率非常的小。真让你写个死锁程序，不一定能写出来，但是，一旦程序发生死锁，程序将死掉。

参考文献

1. Ruthless：Java多线程-线程的同步与锁
2. 徐刘根：Java多线程编程-（1）-线程安全和锁Synchronized概念
3. 长风破浪会有33：线程间的可见性

---