Java线程安全和锁Synchronized知识点详解

一、进程与线程的概念

创新互联专注于昂仁企业网站建设,成都响应式网站建设公司,电子商务商城网站建设。昂仁网站建设公司,为昂仁等地区提供建站服务。全流程定制开发，专业设计，全程项目跟踪，创新互联专业和态度为您提供的服务

（1）在传统的操作系统中，程序并不能独立运行，作为资源分配和独立运行的基本单位都是进程。

在未配置 OS 的系统中，程序的执行方式是顺序执行，即必须在一个程序执行完后，才允许另一个程序执行；在多道程序环境下，则允许多个程序并发执行。程序的这两种执行方式间有着显著的不同。也正是程序并发执行时的这种特征，才导致了在操作系统中引入进程的概念。

自从在 20 世纪 60 年代人们提出了进程的概念后，在 OS 中一直都是以进程作为能拥有资源和独立运行的基本单位的。直到 20 世纪 80 年代中期，人们又提出了比进程更小的能独立运行的基本单位——线程(Thread)，试图用它来提高系统内程序并发执行的程度，从而可进一步提高系统的吞吐量。特别是在进入 20 世纪 90 年代后，多处理机系统得到迅速发展，线程能比进程更好地提高程序的并行执行程度，充分地发挥多处理机的优越性，因而在近几年所推出的多处理机 OS 中也都引入了线程，以改善 OS 的性能。

（2）下图是来自知乎用户的解释：Java线程安全和锁Synchronized概念

通过上述的大致了解，基本知道线程和进程是干什么的了，那么我们下边给进程和线程总结一下概念：

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

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

（5）进程和线程的关系：
Java线程安全和锁Synchronized概念

二、Java实现多线程方式

（1）继承Thread，重写run（）方法

public class MyThread extends Thread {

@Override
public void run() {
  while (true) {
    System.out.println(this.currentThread().getName());
  }
}

public static void main(String[] args) {
  MyThread thread = new MyThread();
  thread.start(); //线程启动的正确方式
}
}

输出结果：

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

另外，要明白启动线程的是start（）方法而不是run（）方法，如果用run（）方法，那么他就是一个普通的方法执行了。

（2）实现Runable接口

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

四、synchronized修饰符

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

（2）不使用synchronized实例（代码A）：

public class MyThread extends Thread {

private int count = 5;

@Override
public void run() {
  count--;
  System.out.println(this.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();
}
}

输出的一种结果如下：

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

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

（3）使用synchronized实例（代码B）：

public class MyThread extends Thread {

private int count = 5;

@Override
public synchronized void run() {
  count--;
  System.out.println(this.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
thread2 count:3
thread3 count:2
thread5 count:1
thread4 count:0

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

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

五、一个对象有一把锁！多个线程多个锁！

何为，一个对象一把锁，多个线程多个锁！首先看一下下边的实例代码（代码C）：

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

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

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
同步的概念就是共享，我们要知道“共享”这两个字，如果不是共享的资源，就没有必要进行同步，也就是没有必要进行加锁；
同步的目的就是为了线程的安全，其实对于线程的安全，需要满足两个最基本的特性：原子性和可见性;

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

（3）示例代码：

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（）就是异步的方法，同时感谢大家对创新互联的支持。

当前标题：Java线程安全和锁Synchronized知识点详解
文章网址：http://chengdu.cdxwcx.cn/article/gjicsc.html

甜橘子，专注成都网站制作网站设计与营销型网站建设与优化

首页

网站建设

网站制作案例

解决方案

网站设计报价

网站制作动态

关于我们

联系我们

成都网站建设设计将想法与焦点和您一起共享

Java线程安全和锁Synchronized知识点详解

其他资讯

flutter关闭app,flutter关闭开机启动权限

bpm系统升级,开源bpm系统

mysql索引怎么设置快,mysql添加索引的时候特别慢

jquery控制div,jquery控制display

linux命令呢,linux 的命令

甜橘子，专注成都网站制作网站设计与营销型网站建设与优化

成都网站建设设计 将想法与焦点和您一起共享

Java线程安全和锁Synchronized知识点详解

其他资讯

flutter关闭app,flutter关闭开机启动权限

bpm系统升级,开源bpm系统

mysql索引怎么设置快,mysql添加索引的时候特别慢

jquery控制div,jquery控制display

linux命令呢,linux 的命令

成都网站建设设计将想法与焦点和您一起共享