关于后端:线程和Synchronized

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

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

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

—– 以上摘自《计算机操作系统 - 汤小丹等编著 -3 版》

（2）下图是来自知乎用户的解释：

通过上述的大抵理解，根本晓得线程和过程是干什么的了，那么咱们下边给过程和线程总结一下概念：

（3）过程（Process）是计算机中的程序对于某数据汇合上的一次运行流动，是零碎进行资源分配和调度的根本单位，是操作系统构造的根底。在晚期面向过程设计的计算机构造中，过程是程序的根本执行实体；在当代面向线程设计的计算机构造中，过程是线程的容器。程序是指令、数据及其组织模式的形容，过程是程序的实体。

（4）线程，有时被称为轻量级过程 (Lightweight Process，LWP），是程序执行流的最小单元。线程是程序中一个繁多的顺序控制流程。过程内一个绝对独立的、可调度的执行单元，是零碎独立调度和分派 CPU 的根本单位指运行中的程序的调度单位。在单个程序中同时运行多个线程实现不同的工作，称为多线程。

（5）过程和线程的关系：

（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(); // 线程启动的正确形式}}
复制代码

《2020 最新 Java 根底精讲视频教程和学习路线！》
输入后果：

Thread-0Thread-0Thread-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

（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:2thread4 count:1thread1 count:2thread2 count:3thread5 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:4thread2 count:3thread3 count:2thread5 count:1thread4 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 = 100thread2 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（）就是异步的办法。

链接：https://juejin.cn/post/690228…

关于后端:线程和Synchronized

一、过程与线程的概念

二、Java 实现多线程形式

三、线程平安

四、synchronized 修饰符

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

六、对象锁的同步和异步

Just My Socks（注册教程内含优惠码）

关于后端:线程和Synchronized

一、过程与线程的概念

二、Java 实现多线程形式

三、线程平安

四、synchronized 修饰符

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

六、对象锁的同步和异步

Just My Socks（注册教程 内含优惠码）

Just My Socks（注册教程内含优惠码）