夜光：Java成神之路（八）擅长的语言

夜光序言：

 

努力是会上瘾的 尤其是尝到甜头以后

 

 

 

 
 
正文：
 
                                              以道御术 / 以术识道

---

---

九、Java 的多线程和并发库

 

对于 Java 程序员来说，多线程在工作中的使用场景还是比较常见的，而仅仅掌握了 Java 中的传统多线程机制，还是不够的。

在 JDK5.0 之后，Java 增加的并发库中提供了很多优秀的 API，在实际开发中用的比较多。

 

因此我们有必要对这部分知识做一个全面的了解。

 

( 1 ) 传统使用类 Thread 和接口 Runnable 实现

 

1.在 Thread 子类覆盖的 run 方法中编写运行代码

 

方式一

package com.hy.多线程高并发;

public class Test {
    public static void main(String[] args) {
        new Thread() {
            @Override
            public void run() {
                while (true) {
                    try {
                        Thread.sleep(2000);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }
            }

        }.start();
    }
}

2.在传递给 Thread 对象的 Runnable 对象的 run 方法中编写代码

 

3.总结

 

查看 Thread 类的 run()方法的源代码，可以看到其实这两种方式都是在调用 Thread 对象的 run 方法

 

如果 Thread类的 run 方法没有被覆盖，并且为该 Thread 对象设置了一个 Runnable 对象，该 run 方法会调用 Runnable 对象的 run 方法

/**
 * If this thread was constructed using a separate
 * <code>Runnable</code> run object, then that
 * <code>Runnable</code> object's <code>run</code> method is called;
 * otherwise, this method does nothing and returns.
 * <p>
 * Subclasses of <code>Thread</code> should override this method.
 *
 * @see #start()
 * @see #stop()
 * @see #Thread(ThreadGroup, Runnable, String)
 */
 @Override
 public void run() {
    if (target != null) {
    target.run();
    }
 }

 

 

( 2 ) 定实现时器 Timer 和 TimerTask

 

 

 

Timer 在实际开发中应用场景不多，一般来说都会用其他第三方库来实现。

 

下面我们就针对来使用 Timer 定时类。

//要求：使用定时器,间隔 4 秒执行一次，再间隔 2 秒执行一次，以此类推执行。


package com.hy.多线程高并发;

import java.util.Date;
import java.util.Timer;
import java.util.TimerTask;



public class Test2 {
    
    
    private static volatile int count = 0;

    static class TimerTastCus extends TimerTask {
        //    private static volatile int count = 0;
        @Override
        public void run() {
            count = (count +1)%2;
            System.err.println("Boob boom ");
            new Timer().schedule(new TimerTastCus(), 2000+2000*count);
        }
    }

    public static void main(String[] args) {
        Timer timer = new Timer();
        timer.schedule(new TimerTastCus(), 2000+2000*count);

        while (true) {
            System.out.println(new Date().getSeconds());
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
// TODO Auto-generated catch block
                e.printStackTrace();
            } }
//PS：下面的代码中的 count 变量中
//此参数要使用在你匿名内部类中，使用 final 修饰就无法对其值进行修改，
//只能改为静态变量
    }
}

 

---

( 3 ) 线程互斥与同步

 

 

在引入多线程后，由于线程执行的异步性，会给系统造成混乱，特别是在急用临界资源时，如多个线程急用同一台打印机，会使打印结果交织在一起，难于区分。

 

 

当多个线程急用共享变量，表格，链表时，可能会导致数据处理出错，

因此线程同步的主要任务是使并发执行的各线程之间能够有效的共享资源和相互合作，从而使程序的执行具有可再现性。

 

当线程并发执行时，由于资源共享和线程协作，使用线程之间会存在以下两种制约关系。

 

 

1. 间接相互制约。一个系统中的多个线程必然要共享某种系统资源，如共享 CPU，共享 I/O 设备，所谓间接相互制约即源于这种资源共享，打印机就是最好的例子，线程 A 在使用打印机时，其它线程都要等待。

 

2. 直接相互制约。这种制约主要是因为线程之间的合作，如有线程 A 将计算结果提供给线程 B 作进一步处理，那么线程 B 在线程 A 将数据送达之前都将处于阻塞状态。

 

 

间接相互制约可以称为 互斥 ，直接相互制约可以称为 同步 ，对于互斥可以这样理解，线程 A 和线程 B 互斥访问某个资源则它们之间就会产个顺序问题——要么线程 A 等待线程 B 操作完毕，要么线程 B 等待线程操作完毕，这其实就 是线程的同步了。

 

因此同步包括互斥，互斥其实是一种特殊的同步。

 

下面我们通过一道题来体会线程的交互。

 

 

要求：子线程运行执行 10 次后，主线程再运行 5 次。这样交替执行三遍

package com.hy.多线程高并发;


/** 
* @Description:  要求：子线程运行执行 10 次后，主线程再运行 5 次。这样交替执行三遍
* @Param:  
* @return:
* @Author: Hy
* @Date: 2019
*/ 

public class Test4 {
    public static void main(String[] args) {
        final Bussiness bussiness = new Bussiness();
//子线程
        new Thread(new Runnable() {
            @Override
            public void run() {
                for (int i = 0; i < 3; i++) {//三遍
                    bussiness.subMethod();  //调用一下这个方法
                } }
        }).start();
//主线程
        for (int i = 0; i < 3; i++) { //三遍
            bussiness.mainMethod();
        }
    }
}


//定义一个类
class Bussiness {

    private boolean subFlag = true;

    //写一个方法   mainMethod
    public synchronized void mainMethod() {
        while (subFlag) {
            try {
                wait();
            } catch (InterruptedException e) {
                e.printStackTrace();
            } }
        for (int i = 0; i < 5; i++) {
            System.out.println(Thread.currentThread().getName()
                    + " : main thread running loop count -- " + i);
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            } }
        subFlag = true;
        notify();
    }

    //写一个方法  subMethod
    public synchronized void subMethod() {
        while (!subFlag) {
            try {
                wait();
            } catch (InterruptedException e) {
                e.printStackTrace();
            } }
        for (int i = 0; i < 10; i++) {
            System.err.println(Thread.currentThread().getName()
                    + " : sub thread running loop count -- " + i);
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            } }
        subFlag = false;
        notify();
    }
}

 

---

( 4 ) 线程局部变量 ThreadLocal

 

ThreadLocal 的作用和目的：用于实现线程内的数据共享，即对于相同的程序代码，多个模块在同一个线程中运行时要共享一份数据，而在另外线程中运行时又共享另外一份数据。

 

 

每个线程调用全局 ThreadLocal 对象的 set 方法，在 set 方法中，首先根据当前线程获取当前线程的 ThreadLocalMap 对象，然后往这个 map 中插入一条记录，key 其实是 ThreadLocal 对象，value 是各自的 set 方法传进去的值。

 

 

也就是每个线程其实都有一份自己独享的 ThreadLocalMap对象，该对象的 Key 是 ThreadLocal 对象，值是用户设置的具体值。

 

 

在线程结束时可以调用 ThreadLocal.remove()方法，这样会更快释放内存，不调 用也可以，因为线程结束后也可以自动释放相关的 ThreadLocal 变量。

 

 

 

ThreadLocal 的应用场景：

 

➢ 订单处理包含一系列操作：减少库存量、增加一条流水台账、修改总账，这几个操作要在同一个事务中完成，通常也即同一个线程中进行处理，如果累加公司应收款的操作失败了，则应该把前面 的操作回滚，否则，提交所有操作，这要求这些操作使用相同的数据库连接对象，而这些操作的代码 分别位于不同的模块类中。

 

 

➢ 银行转账包含一系列操作： 把转出帐户的余额减少，把转入帐户的余额增加，这两个操作要在同一个事务中完成，它们必须使用相同的数据库连接对象，转入和转出操作的代码分别是两个不同 的帐户对象的方法。

 

 

➢ 例如 Strut2 的 ActionContext，同一段代码被不同的线程调用运行时，该代码操作的数据是每 个线程各自的状态和数据，对于不同的线程来说，getContext 方法拿到的对象都不相同，对同一个 线程来说，不管调用 getContext 方法多少次和在哪个模块中 getContext 方法，拿到的都是同一 个。