线程与同步

时间  2019-12-10
标签 线程 同步 繁體版
原文   原文链接

1、线程

　　1.1多线程原理

　　咱们先定义一个线程类，代码以下：java

 1 package com.buwei;
 2 
 3 /**
 4  * @author buwei
 5  * @date 2018/12/24 20:07
 6  */
 7 public class MyThread extends Thread {
 8     /**
 9      * 利用继承中的特色
10      * 将线程名称传递,进行设置
11      *
12      * @param name 线程的名称
13      */
14     public MyThread(String name) {
15         super(name);
16     }
17 
18     /**
19      * 重写run方法
20      * 定义线程要执行的代码
21      */
22     @Override
23     public void run() {
24         for (int i = 0; i < 20; i++) {
25             // getName（）方法来自父亲
26             System.out.println(getName() + i);
27         }
28     }
29 }

　　再定义一个测试类，以下：编程

 1 package com.buwei;
 2 
 3 /**
 4  * @author buwei
 5  * @date 2018/12/24 20:15
 6  */
 7 public class MyThreadTest {
 8     public static void main(String[] args) {
 9         MyThread mt = new MyThread("小强");
10         // 开启新的线程
11         mt.start();
12         for (int i = 0; i < 20; i++) {
13             System.out.println("旺财" + i);
14         }
15     }
16 }

　　执行流程图以下：安全

 

　　程序启动时运行main时候，Java虚拟机启动一个进程，主线程main在main()调用的时候被建立，随着调用mt对象的start方法，另一个新的线程也启动了，这样，这个应用就在多线程下运行。要想让效果看起来更明显一些，咱们可让打印的次数更多一些来执行。多线程

　　多线程在执行时，在栈内存中，每个执行线程都有一片本身所属的栈内存空间，进行方法的压栈和弹栈。ide

　　当执行线程的任务结束了，线程自动在栈内存中释放了，可是当全部的执行线程都结束了，那么进程就结束了。测试

 　　1.2 Thread类

　　构造方法：this

  • public Thread()：分配一个新的线程对象
  • public Thread(String name)：分配一个指定名字的新的线程对象
  • public Thread(Runable target)：分配一个带有指定目标新的线程对象
  • public Thread(Runable target，String name)：分配一个带有执行目标新的线程对象并指定名字

 　　经常使用方法：spa

  • public String getName()：获取当前线程名称
  • public void start()：致使此线程开始执行；Java虚拟机调用此线程的run方法
  • public void run()： 此线程要执行的任务在此处定义代码
  • public static void sleep(Long milllis)：使当前正在执行的线程以指定的毫秒数暂停（暂时中止执行）
  • public static Thread currentThread()：返回对当前正在执行的线程对象的引用

 　　咱们在查询API后能够得知建立线程的方式总共有两种，一种是继承Thread类方法，一种是时间Runable接口方式，前面的咱们展现的是第一种，如今咱们讲解第二种操作系统

　　1.3 建立线程的方式二

　　采用Java.lang.Runnable也是很是常见的方法之一，咱们只须要重写run方法便可.net

　　步骤以下：

  • 定义Runnable接口的实现类，而且重写该接口的run()方法，该run()方法的方法体一样是该线程的执行体
  • 建立Runnable实现类的实例，并以此实例做为Thread的target来建立Thread对象，该Thread对象才是真正的线程对象
  • 调用线程对象的start()方法来启动线程

　　代码以下：

 1 package com.buwei;
 2 
 3 /**
 4  * @author buwei
 5  * @date 2018/12/24 20:53
 6  */
 7 public class MyRunnable implements Runnable{
 8     @Override
 9     public void run() {
10         for (int i = 0; i < 20; i++) {
11             System.out.println(Thread.currentThread().getName()+i);
12         }
13     }
14 }
 1 package com.buwei;
 2 
 3 /**
 4  * @author buwei
 5  * @date 2018/12/24 20:55
 6  */
 7 public class MyRunnableTest {
 8     public static void main(String[] args) {
 9         // 建立自定义类对象，线程任务对象
10         MyRunnable mr = new MyRunnable();
11         // 建立线程对象
12         Thread t = new Thread(mr, "小强");
13         t.start();
14         for (int i = 0; i < 20; i++) {
15             System.out.println("旺财" + i);
16         }
17     }
18 }

　　经过实现Runnable接口，使得该类有了多线程类的特性。run()方法是多线程程序的一个执行目标。全部的多线程代码都在run方法中，Thread类实际上也是实现了Runnable接口的类。

　　在启动多线程的时候，须要先经过Thread类的构造方法Thread(Runnable targer)构造出对象，而后调用Thread对象的start()方法来运行多线程代码。

　　实际上全部的所线程代码都是经过Thread的start()方法来运行的，所以，不论是继承Thread类仍是实现Runnable接口来实现多线程，最终仍是经过Thread对象的API来控制线程的，熟悉Thread类的API是进行多线程编程的基础。

　　tips：Runnable对象仅仅做为Thread对象的target，Runnable实现类里包含的run方法仅做为线程执行体。而时间的线程对象依然是Thread实例，只是该Thread线程负责执行其target的run()方法。

　　1.4 Thread和Runable的区别

　　若是一个类继承Thread，则不适合资源共享，可是若是实现了Runnable接口的话，则很容易的实现资源共享。

　　总结：实现Runnable接口比继承Thread类所具备的优点：

  1. 适合锁哥相同的程序代码的线程去共享一个资源
  2. 能够避免Java中出现单继承的局限性
  3. 增长线程的健壮性，实现解耦操做，代码能够被多个线程共享，代码和线程独立
  4. 线程池只能放入实现Runnable或者Callable类线程，不能直接放入继承Thread的类

　　补充：在Java中，每次程序的运行至少启动两个线程。一个是main线程，一个是垃圾收集线程。由于每当使用Java命令执行一个类的时候，实际上都会启动一个JVM，每个JVM其实就是在操做系统中启动了一个进程

　　1.5 匿名内部类方式实现线程的建立

　　使用线程的匿名内部类的方式，能够方便的实现每一个线程执行不一样的线程操做。

　　使用匿名内部类的方式实现Runable接口，重写Runnable接口中的run()方法：

 1 package com.buwei;
 2 
 3 /**
 4  * @author buwei
 5  * @date 2018/12/24 21:15
 6  */
 7 public class NoNameInnerClassThread {
 8     public static void main(String[] args) {
 9         Runnable r = new Runnable() {
10             @Override
11             public void run() {
12                 for (int i = 0; i < 20; i++) {
13                     System.out.println("小强" + i);
14                 }
15             }
16         };
17         new Thread(r).start();
18         for (int i = 0; i < 20; i++) {
19             System.out.println("旺财" + i);
20         }
21     }
22 }

2、线程安全

　　2.1 线程安全

　　若是有多个线程在同时运行，而这些线程可能会同时运行这段代码。程序每次运行的结构单线程同样的，并且其余的变量的值也和预期的是同样的，就是线程安全的。

　　咱们用一个生活中常见的电影院卖票的案例来演示线程的安全问题：

　　咱们模拟电影院如今要播放一场电影，《楚门的世界》，本次电影总共是有100个座位，三个窗口同时开启卖票。

　　用线程对象来模拟窗口，票的张数来模拟Runnable接口的子类

 1 package com.buwei;
 2 
 3 /**
 4  * @author buwei
 5  * @date 2018/12/24 21:24
 6  */
 7 public class Ticket implements Runnable {
 8     private int ticket = 100;
 9     @Override
10     public void run() {
11         // 每一个窗口均可以执行卖票，窗口所有开启
12         while (true){
13             // 有票能够卖
14             if (ticket > 0){
15                 try {
16                     // sleep模拟出票时间
17                     Thread.sleep(100);
18                 } catch (InterruptedException e) {
19                     e.printStackTrace();
20                 }
21                 // 获取当前线程对象的名字
22                 String name = Thread.currentThread().getName();
23                 System.out.println(name + "正在卖第" + ticket-- + "张票");
24             }
25         }
26     }
27 }
 1 package com.buwei;
 2 
 3 /**
 4  * @author buwei
 5  * @date 2018/12/24 21:29
 6  */
 7 public class TicketTest {
 8     public static void main(String[] args) {
 9         // 建立线程任务对象
10         Ticket ticket = new Ticket();
11         // 建立撒个窗口对象
12         Thread thread1 = new Thread(ticket, "窗口1");
13         Thread thread2 = new Thread(ticket, "窗口2");
14         Thread thread3 = new Thread(ticket, "窗口3");
15 
16         //三个窗口同时卖票
17         thread1.start();
18         thread2.start();
19         thread3.start();
20     }
21 }

　　这时候就会出现问题：

　　后面的票提早卖，票被超卖，以及票被重复卖等等问题。

　　这种问题，就是由于几个窗口的票数不一样步了，咱们称之为线程不安全

　　线程安全问题都是由全局变量和静态变量引发的，若是每一个线程对全局变量、静态变量只有读操做，而无写操做，通常来讲，这个全局变量时线程安全的，可是若是有多个线程同时执行写操做，咱们就要考虑线程安全的问题了。

　　2.2 线程同步

　　Java中对于多线程的问题提供了同步机制（synchronized）来解决这个问题。

　　有三种方式能够完成同步操做：

  • 同步代码块
    • synchronized关键字能够用于方法中的某个区域中，表示对这个区块的资源实行互斥访问，格式以下：
    • 1 synchronized（同步锁）{
2      须要同步操做的代码  
3 }
    • 同步锁：对象的同步锁只是一个概念，能够想象为在对象上标记了一个锁
      • 锁对象能够是任意类型
      • 多个线程对象要使用同一把锁
      • 注意：在任什么时候候，最多容许一个线程拥有同步锁进入代码块，其余的线程只能在外面等着
      •  1 package com.buwei;
 2 
 3 /**
 4  * @author buwei
 5  * @date 2018/12/24 21:24
 6  */
 7 public class Ticket implements Runnable {
 8     private int ticket = 100;
 9 
10     @Override
11     public void run() {
12         // 每一个窗口均可以执行卖票，窗口所有开启
13         synchronized (this){
14             while (true){
15                 // 有票能够卖
16                 if (ticket > 0){
17                     try {
18                         // sleep模拟出票时间
19                         Thread.sleep(100);
20                     } catch (InterruptedException e) {
21                         e.printStackTrace();
22                     }
23                     // 获取当前线程对象的名字
24                     String name = Thread.currentThread().getName();
25                     System.out.println(name + "正在卖第" + ticket-- + "张票");
26                 }
27             }
28        }
29     }
30 }
  • 同步方法
    • 使用synchronized修饰的方法，就叫作同步方法，保证线程A执行该方法的时候其余线程只能在方法外等着，格式以下：
    • 1 public synchronized void method(){
2     可能会产生线程安全问题的代码  
3 }
    • 对于非static方法，同步锁就是this
    • 对于static方法，咱们使用当前方法所在类的字节码对象（类名.class）
    • 使用同步方法代码以下：
    •  1 package com.buwei;
 2 
 3 /**
 4  * @author buwei
 5  * @date 2018/12/24 21:24
 6  */
 7 public class Ticket implements Runnable {
 8     private int ticket = 100;
 9 
10     @Override
11     public void run() {
12         // 每一个窗口均可以执行卖票，窗口所有开启
13         while (true) {
14             sellTicket();
15         }
16     }
17 
18     public synchronized void sellTicket(){
19         // 有票能够卖
20         if (ticket > 0){
21             try {
22                 // sleep模拟出票时间
23                 Thread.sleep(100);
24             } catch (InterruptedException e) {
25                 e.printStackTrace();
26             }
27             // 获取当前线程对象的名字
28             String name = Thread.currentThread().getName();
29             System.out.println(name + "正在卖第" + ticket-- + "张票");
30         }
31     }
32 }

  •  Lock锁：java.util.concurrent.locks.Lock机制提供了比synchronized代码块和synchronized方法更普遍的锁定操做，同步代码块/同步方法具备的功能Lock都有，除此以外更强大，更体现面向对象

  • public void lock()：加同步锁
  • public void unlock()：释放同步锁
  • public void trylock()：若是获取锁的时候锁被占用就返回false，不然返回true
  • 使用以下：
  •  1 package com.buwei;
 2 
 3 import java.util.concurrent.locks.Lock;
 4 import java.util.concurrent.locks.ReentrantLock;
 5 
 6 /**
 7  * @author buwei
 8  * @date 2018/12/24 21:24
 9  */
10 public class Ticket implements Runnable {
11     private int ticket = 100;
12 
13     Lock lock = new ReentrantLock();
14 
15     @Override
16     public void run() {
17         // 每一个窗口均可以执行卖票，窗口所有开启
18         while (true) {
19             lock.lock();
20             // 有票能够卖
21             if (ticket > 0) {
22                 try {
23                     // sleep模拟出票时间
24                     Thread.sleep(100);
25                 } catch (InterruptedException e) {
26                     e.printStackTrace();
27                 }
28                 // 获取当前线程对象的名字
29                 String name = Thread.currentThread().getName();
30                 System.out.println(name + "正在卖第" + ticket-- + "张票");
31             }
32             lock.unlock();
33         }
34     }
35 }

 3、线程状态

 　　3.1 线程状态概述

 　　当线程被建立并启动之后，它即不是一启动就进入了执行状态，也不是一直处于执行状态。在线程的生命周期中，在线程的生命周期中，在Java.lang.Thread.State枚举类中给了六种线程状态：

　　3.2 Timed Waiting（计时等待）

　　描述：一个正在限时等待另外一个线程执行一个（唤醒）动做的线程处于这一状态。

　　在咱们在的run方法方法中添加sleep语句就是所谓的TimedWaiting计时等待

  • 进入Timed_Waiting状态的一种常见情形是调用的sleep方法，单独的线程也能够调用，不必定非要有协做关系
  • 为了让其余线程有机会执行，能够将Thread.sleep()的调用放在线程run()以内，这样才能保证该线程执行过程当中睡眠
  • sleep与锁无关，线程睡眠到期自动苏醒，并返回到Runnable（可运行）状态

 　　sleep()中指定的时间是线程不会运行的最短期。所以，sleep()方法不能保证该线程睡眠到期后就开始like执行

 　　Timed Waiting线程状态图

　　3.3 Blocked(锁阻塞)

 　　描述：一个正在阻塞等待一个监视器锁（锁对象）的线程处于这一状态。

　　好比：线程A与线程B代码中使用同一锁，若是线程A获取到锁，线程A进入到Runnable状态，name线程B就进入到Blocked锁阻塞状态。

　　这是由Runnable状态进入Blocked状态。除此Waiting以及Time Waiting状态也会在某种状况下进入阻塞状态，Blocked线程状态图以下：

　　3.4 Waiting（无线等待）

 　　描述：一个正在无限期等待另外一个线程执行一个特别的（唤醒）动做的线程处于这一状态。

　　Waiting线程状态图：

　　

　　3.5 补充知识点

　　tips：咱们在翻阅API的时候会发现Timed Waiting（计时等待） 与 Waiting（无限等待） 状态联系仍是很紧密的，好比Waiting（无限等待） 状态中wait方法是空参的，而timed waiting（计时等待） 中wait方法是带参的。这种带参的方法，实际上是一种倒计时操做，至关于咱们生活中的小闹钟，咱们设定好时间，到时通知，但是若是提早获得（唤醒）通知，那么设定好时间在通知也就显得画蛇添足了，那么这种设计方案实际上是一箭双雕。若是没有获得（唤醒）通知，那么线程就处于Timed Waiting状态,直到倒计时完毕自动醒来；若是在倒计时期间获得（唤醒）通知，那么线程从Timed Waiting状态马上唤醒。

4、Lock锁和synchronized的区别

　　下表来自：https://blog.csdn.net/u012403290/article/details/64910926

相关文章
相关标签/搜索
每日一句
    每一个你不满意的现在，都有一个你没有努力的曾经。
本站公众号
   欢迎关注本站公众号,获取更多信息
联系我们 最近搜索 最新文章 沪ICP备13005482号-10 MyBatis教程 SQL 教程 MySQL教程 Java 教程 Thymeleaf 教程 Hibernate教程 Spring教程 Redis教程