[Java] 9.多线程

最新推荐文章于 2020-12-17 17:22:44 发布
转载 最新推荐文章于 2020-12-17 17:22:44 发布 · 141 阅读 · 0 ·
CC 4.0 BY-SA版权
原文链接：https://www.cnblogs.com/adamjwh/p/8654008.html

前面我们系统的了解了Java的基础知识，本篇开始将进入到Java更深层次的介绍，我们先来介绍一下Java中的一个重要的概念——线程。

一、什么是线程

　　在了解线程前，我们首先要了解进程的概念。进程是操作系统调度和分配资源的基本单位，进程之间的通信需要通过专门的系统机制，比如消息、socket和管道来完成。而线程是比进程更小的执行单位，每个线程拥有自己的栈和寄存器等资源数据，多个线程之间共享进程的代码、数据和文件。

　　那为什么要引入线程的概念？或者说线程有什么优点？

　　举个简单的例子，我们在使用电脑时，可以使用它听歌，可以使用它打印文件，也可以使用它看电影，而这些活动完全可以同时进行，这种思想在Java中被称为并发，线程就是并发完成的每一件事情。

　　线程的优点有如下几条：

  1. 创建一个线程比创建一个进程的代价要小
  2. 线程的切换比进程间的切换代价小
  3. 充分利用多处理器
  4. 数据共享（数据共享使得线程之间的通信比进程间的通信更高效）
  5. 快速响应特性（在系统繁忙的情况下，进程通过独立的线程及时响应用户的输入 ）

　　在单线程中，程序代码按调用顺序依次往下执行，如果需要一个进程同时完成多段代码的操作，就需要产生多线程。

二、线程的实现

　　在Java中主要提供了两种方式实现线程，下面分别介绍一下这两种方式。

　　1. 继承Thread类

　　在Java中可通过继承java.lang.Thread类来实现线程，语法格式如下：

public class MyThread extends Thread {
    //...
}

　　而完成线程真正功能的代码在run()方法中，且run()方法的语法格式固定，如下：

public void run() {
    //...
}

　　之后通过调用start()方法启动线程，如果start()方法调用一个已经启动的线程，会抛出IllegalThreadStateException异常。

　　下面看一个实例。

public class MyThread extends Thread {

    private static int i=0;
    
    public void run() {
        i++;    
        System.out.println(i);    
    }
    
    public static void main(String[] args) {
        MyThread myThread1 = new MyThread();
        MyThread myThread2 = new MyThread();
        MyThread myThread3 = new MyThread();
        myThread1.start();
        myThread2.start();
        myThread3.start();
    }
}

 

这里定义了三个线程，分别执行start()方法，运行结果如下：

　　

　　如果不调用start()方法，线程永远都不会启动，在主方法没有调用start()方法之前，Thread对象只是一个实例，而不是一个真正的线程。

　　2. 实现Runnable接口

　　我们知道每次只能继承一个类，如果此时要在使用线程的前提下还要继承其他类，就需要使用Runnable接口了。语法格式如下：

public class MyThread implements Runnable {
    //...
}

　　如果还要继承其他类，语法格式如下：

public class MyThread extends Object implements Runnable {
    //...
}

　　实现Runnable接口的程序会创建一个Thread对象，并将Runnable对象与Thread对象相关联。例如如下代码：

new Thread(new Runnable(){

　　@Override
　　public void run() {
　　　　i++;    
　　　　System.out.println(i);    
　　}

}).start();

 

　在Thread对象中实现Runnable接口，并将其start()。

三、生命周期

　　线程的生命周期包含出生状态、就绪状态、运行状态、等待状态、休眠状态、阻塞状态和死亡状态7种状态。当用户创建线程时线程处于出生状态；在用户调用start()方法后线程处于就绪状态；当线程得到资源后进入运行状态；当在运行态调用wait()方法时线程处于等待状态，此时必须调用notify()方法才能被唤醒，notifyAll()可以唤醒所有处于等待状态下的线程；当线程调用sleep()方法时会进入休眠状态；如果一个线程在运行状态下发出输入/输出请求，该线程将进入阻塞状态，在其等待输入/输出结束时线程进入就绪状态；当线程的run()方法执行完毕时线程进入死亡状态。（具体内容可参考操作系统）

　　下图为线程生命周期状态图，可对照上述文字加以理解。

四、线程的休眠/加入/中断/礼让

　　1. 线程的休眠(sleep)

　　调用sleep()方法，该方法需要一个参数用于指定线程休眠时间，单位为ms，通常用在run()方法内的循环中被使用，注意要使用try···catch包围。语法格式如下：

try {
    Thread.sleep(1000);
} catch(InterruptedException e) {
    e.printStackTrace();
}

　　使用了sleep()方法的线程在一段时间内会醒来，但是并不能保证它醒来后进入运行状态，只能保证它进入就绪状态。

　　2. 线程的加入(join)

　　假设有一个线程A，现在需要插入线程B，并要求线程B先执行完毕，然后再继续执行线程A，此时可以使用join()方法来完成。当某个线程使用join()方法加入到另一个线程时，另一个线程会等待该线程执行完毕再继续执行。语法格式如下：

Thread.join();

　　3. 线程的中断(stop/interrupt)

　　stop()方法可以停止线程，但JDK早已废除，同时也不建议使用stop()方法来停止一个线程的运行。可在run()方法中使用无限循环的形式，然后使用一个布尔型标记控制循环的停止。如下：

public class InterruptedTest implements Runnable {

    private boolean isContinue = false;        //标记变量，默认值为false
    
    @Override
    public void run() {
        while(true) {
            //... 此部分代码省略
            if(isContinue) {        //为true时，停止线程
                break;
            }
        }
    }
    
}

如果线程因为使用了sleep()或wait()方法进入了就绪状态，这时可以使用Thread类中的interrupt()方法使线程离开run()方法，同时结束线程，但会抛出InterruptedException异常。语法格式如下：

Thread.interrupt();

　　4. 程序的礼让(yield)

　　Thread类中提供了一种礼让方法yield()，用于给当前正处于运行状态下的线程一个提醒，告知它可以将资源礼让给其他线程。

　　yield()方法使具有同样优先级的线程有进入可执行状态的机会，当当前线程放弃执行权时会再度回到就绪状态。

五、线程同步

　　多线程中，可能会发生两个线程抢占资源的问题，例如两个人同时过一个独木桥。所以Java提供线程同步机制来防止这些资源访问的冲突。

　　1. 线程同步机制

　　在多线程中，多个线程共享同一个资源可能会出现一些问题，比如下面这个例子，火车售票系统。

public class ThreadSafeTest implements Runnable {

    int num = 10;
    
    @Override
    public void run() {
        while(true) {
            if(num>0) {
                try {
                    Thread.sleep(100);
                } catch (Exception e) {
                    e.printStackTrace();
                }
                System.out.println("车票剩余：" + num-- + "张");
            }
        }
    }

    public static void main(String[] args) {
        ThreadSafeTest test = new ThreadSafeTest();
        Thread tA = new Thread(test);        //实例化4个线程
        Thread tB = new Thread(test);
        Thread tC = new Thread(test);
        Thread tD = new Thread(test);
        tA.start();        //启动线程
        tB.start();
        tC.start();
        tD.start();
    }
    
}

 

运行结果如下：

　　

　　这里出现了剩余-1张的情况，究其原因是因为同时创建了4个线程，都执行run()方法时，四个线程对num都有储存功能，当线程1执行run()方法时，还没来得及递减，此时线程2、3、4都进入了run()方法，发现num仍大于0，但此时线程1休眠时间已到，将num变量递减，同时线程2、3、4也对num变量进行递减操作，从而产生了负值。同理出现多次十张的情况也是互相抢占了资源。换句话说就是产生了资源冲突问题，为了解决这种问题，就需要给共享资源上一道锁。最简单的例子就是上洗手间，一个人进去后要将门锁上，当他出来时再将锁打开，然后其他人才可以进。

　　我们使用同步块或同步方法来实现加锁操作。语法结构分别如下：

synchronzied(Object) {
    //... 
}
synchronzied void test() {
    //...
}

　　可将上述代码改为

public class ThreadSafeTest implements Runnable {

    int num = 10;
    
    @Override
    public void run() {
        while(true) {
            synchronized ("") {        //加锁        
                if(num>0) {
                    try {
                        Thread.sleep(100);
                    } catch (Exception e) {
                        e.printStackTrace();
                    }
                    System.out.println("车票剩余：" + num-- + "张");
                }
            }
        }
    }

    public static void main(String[] args) {
        ThreadSafeTest test = new ThreadSafeTest();
        Thread tA = new Thread(test);        //实例化4个线程
        Thread tB = new Thread(test);
        Thread tC = new Thread(test);
        Thread tD = new Thread(test);
        tA.start();        //启动线程
        tB.start();
        tC.start();
        tD.start();
    }
    
}

 也可以用同步方法如下：

public synchronized void doit() {        //定义同步方法
    if(num>0) {
        try {
            Thread.sleep(100);
        } catch (Exception e) {
            e.printStackTrace();
        }
    System.out.println("车票剩余：" + num-- + "张");
    } 
}

两种方法运行结果一致，运行结果如下：

　　

六、线程实例测试

　　下面举一个完整的例子。

　　对归并排序使用多线程进行求解，排序数据量不少于1M。

　　1. 程序结构

　　

　　2. MakeArrays.java

　　该类用于创建一个1M的随机测试数组，用于保证样本的统一性（串行与并行使用同一个数组）。

import java.util.Random;

public class MakeArrays {

    private int length = 1024*1024;
    
    public int[] makeArray() {
        int[] array = new int[length];
        
        Random random = new Random();
        for(int i=0; i<length; i++) {
            int x = random.nextInt();
            array[i] = x;
        }
        
        return array;
    }
    
}

3. MergeSort.java

　　此部分用来编写归并排序算法。

public class MergeSort {

    public static void sort(int[] array){
        int length = array.length;
        int[] tmpArray = new int[ length ];
        sort(array, tmpArray, 0, length-1);
    }

    public static void sort(int[] array, int[] tmpArray, int left, int right){
        if(left < right){
            int center = (left + right)/2;    //取中间值
            sort(array, tmpArray, left, center);    //递归分解
            sort(array, tmpArray, center+1, right);    //递归分解
            merge(array, tmpArray, left, center+1, right);    //合并排序
        }
    }

    private static void merge(int[] array, int[] tmpArray, int leftStart, int rightStart, int rightEnd) {
        int leftEnd = rightStart - 1;    //左侧数组截止下标
        int tmpPos = leftStart;    //数组坐标
        int total = rightEnd - leftStart + 1;    //需要合并的数组元素数量

        while(leftStart <= leftEnd && rightStart <= rightEnd){
            if(array[ leftStart ] <= array[ rightStart ]){
                //如果左侧数组元素小于或等于右侧数组元素，将左侧数组元素的值存入临时数组，并移动左侧数组下标
                tmpArray[ tmpPos++ ] = array[ leftStart++ ];
            }else{
                //如果左侧数组元素大于右侧数组元素，将右侧数组元素的值存入临时数组，并移动右侧数组下标
                tmpArray[ tmpPos++ ] = array[ rightStart++ ];
            }
        }

        //如果左侧数组元素没有全部存入临时数组，将剩余元素循环写入临时数组
        while(leftStart <= leftEnd){
            tmpArray[ tmpPos++ ] = array[ leftStart++ ];
        }

        //如果右侧数组元素没有全部存入临时数组，将剩余元素循环写入临时数组
        while(rightStart <= rightEnd){
            tmpArray[ tmpPos++ ] = array[ rightStart++ ];
        }

        //将临时数组中排序好的元素写入原数组
        for(int i = 0; i < total; i++, rightEnd-- ){
            array[ rightEnd ] = tmpArray[ rightEnd ];
        }

    }

}

 4. SerialDemo.java

　　该类为串行代码，即不使用线程的情况下直接调用归并排序算法。

public class SerialDemo2_5 {

    public void mergeSort(int[] array) {
        //归并排序
        MergeSort.sort(array);
    }
    
}

 

　5. ThreadDemo.java

　　该类为并行代码，即使用多线程的情况下调用归并排序算法，这里以两个线程为例，将前面的1M的数组平均分为两份，分别交给这两个线程进行归并排序处理，然后再对其合并排序，得到最终的数组。

import java.util.concurrent.CountDownLatch;

public class ThreadDemo2_5 {

    public void mergeSort(int[] array) throws InterruptedException {
        int length = array.length;
        
        int minLength = length/2;
        int[] a = new int[minLength];
        int[] b = new int[minLength];

        for(int i=0; i<2; i++){
            int start = minLength * i;
            int end = minLength * (i + 1);

            if(i==0){
                for(int j=start, k=0; j<end; j++,k++){
                    a[k] = array[j];
                }
            }else if(i==1){
                for(int j=start, k=0; j<end; j++,k++){
                    b[k] = array[j];
                }
            }
        }

        //使用CountDownLatch来确保两个子线程都处理完毕后才执行最后的归并操作
        CountDownLatch latch = new CountDownLatch(2);
        new Thread(new Runnable(){

            @Override
            public void run() {
                MergeSort.sort(a);
                latch.countDown();
            }

        }).start();

        new Thread(new Runnable(){
            @Override
            public void run() {
                MergeSort.sort(b);
                latch.countDown();
            }
        }).start();

        //等待
        latch.await();

        //合并两个有序序列
        merge(a, b, array);
        
    }

    //合并序列
    private static void merge(int[] a1, int[] a2, int[] tmpArray){
        int length1 = a1.length;
        int length2 = a2.length;

        int left = 0;
        int right = 0;
        int pos = 0;

        while(left < length1 && right < length2){
            if(a1[left] <= a2[right]){
                tmpArray[pos] = a1[left];
                left++;
            }else{
                tmpArray[pos] = a2[right];
                right++;
            }
            pos++;
        }

        while(left < length1){
            tmpArray[ pos++ ] = a1[ left++ ];
        }

        while(right < length2){
            tmpArray[ pos++ ] = a2[ right++ ];
        }

    }
    
}

 

　　6. Main.java

　　这里为主函数用于测试串行与并行的时间有何差别。

public class MainEx2_5 {
    
    private static int[] array = new MakeArrays().makeArray();
    
    /**
     * 测试函数
     * @param args
     * ms : currentTimeMillis
     * ns : nanoTime
     */
    public static void main(String[] args) {
        /**
         * 串行测试
         */
        long startTime = System.currentTimeMillis();   //获取开始时间
        new SerialDemo2_5().mergeSort(array);  //测试的代码段
        long endTime = System.currentTimeMillis(); //获取结束时间
        System.out.println("串行使用的时间： "+(endTime-startTime)+"ms");
        
        /**
         * 线程测试
         */
        long startTime1 = System.currentTimeMillis();   //获取开始时间
        try {
            new ThreadDemo2_5().mergeSort(array);
        } catch (InterruptedException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }  //测试的代码段
        long endTime1 = System.currentTimeMillis(); //获取结束时间
        System.out.println("线程使用的时间： "+(endTime1-startTime1)+"ms");
    }

}

 

7. 运行结果

　　

　　从这里可以看出并行的时间比线程少了很多，提高了效率。

　　这里再给另一种简单的代码，换了一种方法，可以自行理解。如下对随机产生的1M-10M的数组进行求和，这里只给出线程部分的代码（这个代码可以实现线程数自定）。

public class ThreadDemo1_1 {

    /**
     * 对数组求和
     * @param array 数组
     * @param threadCount 线程数
     * @return 数组元素和
     */
    public long sumArray(final int[] array, int threadCount) {
        if (array == null || array.length == 0) {
            throw new IllegalArgumentException("数组长度必须大于0");
        }

        final RuntimeSave rd = new RuntimeSave();     // 保存数据
        final int lenPerThread = array.length / threadCount;  // 计算每个线程的数组元素个数
        
        for (int i = 0; i < threadCount; i++) {
            final int index = i;
            new Thread() {
                @Override
                public void run() {
                    long s = 0;
                    int start = index * lenPerThread;
                    int end = start + lenPerThread;
                    
                    for (int j = start; j < end; j++) {
                        s += array[j];
                    }
                    synchronized (rd) {
                        rd.sum += s;
                        rd.finishThreadCount++;
                    }
                };
            }.start();
        }
   
        int remain = array.length % threadCount;      // 剩余数组元素
        long s = 0;
        
        for (int i = array.length - remain; i < array.length; i++) {
            s += array[i];  
        }
        synchronized (rd) {  
            rd.sum += s;
        }
        
        while (rd.finishThreadCount != threadCount) {
            try {
                Thread.sleep(1);
            } catch (InterruptedException e) {
                e.printStackTrace();
                break;
            }  
        }  
        return rd.sum;
    }
    
    /**
     * 保存运行时的相关数据
     * @author adamjwh
     *
     */
    static class RuntimeSave {
        long sum;  // 保存求和
        int finishThreadCount;  // 已执行完毕的线程数
    }
}

 

Java多线程编程-（9）-使用线程池实现线程的复用和一些坑的避免
Java后端技术
10-17 1234
前几篇： Java多线程编程-（1）-线程安全和锁Synchronized概念 Java多线程编程-（2）-可重入锁以及Synchronized的其他基本特性 Java多线程编程-（3）-从一个错误的双重校验锁代码谈一下volatile关键字 Java多线程编程-（4）-线程本地ThreadLocal的介绍与使用 Java多线程编程-（5）-线程间通信机制的介绍与使用
实战指南：理解 ThreadLocal 原理并用于Java 多线程上下文管理
热门推荐
张彦峰的博客
12-01 10万+
探讨如何基于实现一个高效的上下文管理组件，以解决多线程环境下的数据共享和上下文管理这些问题。通过具体的代码示例和实战展示如何为多线程编程提供一种简洁而高效的上下文管理方案。
Java多线程9：ThreadLocal源码剖析
weixin_33850015的博客
10-04 208
ThreadLocal源码剖析 ThreadLocal其实比较简单，因为类里就三个public方法：set(T value)、get()、remove()。先剖析源码清楚地知道ThreadLocal是干什么用的、再使用、最后总结，讲解ThreadLocal采取这样的思路。   三个理论基础 在剖析ThreadLocal源码前，先讲一下ThreadLocal的三个理论基础： 1、每个线程都...
Java高级篇（一）——线程
weixin_34380781的博客
03-26 120
　　前面我们系统的了解了Java的基础知识，本篇开始将进入到Java更深层次的介绍，我们先来介绍一下Java中的一个重要的概念——线程。 一、什么是线程 　　在了解线程前，我们首先要了解进程的概念。进程是操作系统调度和分配资源的基本单位，进程之间的通信需要通过专门的系统机制，比如消息、socket和管道来完成。而线程是比进程更小的执行单位，每个线程拥有自己的栈和寄存器等资源数据，多个线程之间共...
Java多线程9 多线程的提高
Stitch__的博客
08-14 338
之前的内容：理解多线程。创建多线程。多线程的安全问题/分析与理解。安全问题的解决办法/锁 ———————————多线程的提高    线程之间的通信————————————— 之前的例子都是多个线程执行一个线程任务，多线程的提高——多个线程执行不同的线程任务，并发执行 例如：消费者与生产者，一个消费一个生产，执行的线程任务不同，但是处理的资源是一样的。但是要求同时进行 这叫做线程间的通信——...
Java >> 9. 多线程
原谅我这一生不羁放纵爱自由
07-06 216
线程概念 进程和线程 进程：当执行一个程序时，要给程序分配内存、外设等资源，并等候处理器的调度执行程序中的指令。程序执行完毕后，系统要收回所分配的资源。这样一个过程就是进程。 进程是一个具有一定独立功能的程序在一个数据集合上的一次动态执行过程。 进程是存储器、外设等资源的分配单位，也是处理器的调度对象。 每个进程都有自己独立的内存空间和资源，进程之间不会共享系统资源。 线程：比进程更小的运行单位...
Java多线程学习Java多线程学习Java多线程学习Java多线程学习.txt
05-15
Java多线程学习Java多线程学习Java多线程学习Java多线程学习Java多线程学习Java多线程学习Java多线程学习Java多线程学习Java多线程学习Java多线程学习Java多线程学习Java多线程学习Java多线程学习Java多线程学习Java...
多线程java.util.ConcurrentModificationException异常问题分析和处理
CMZ_one的博客
12-17 1341
多线程java.util.ConcurrentModificationException异常问题分析和处理 在Java中，多线程和Map使使用频率最高的两兄弟了，今天突然被刚入职不久的同事问到，多线程处理Map时会偶尔报异常，直接看代码 import java.util.Collections; import java.util.HashMap; import java.util.Hashtable; import java.util.Map; import java.util.concurrent.*;
java多线程查询数据库
12-04
综上所述，"java多线程查询数据库"是一个涉及多线程技术、线程池管理、并发控制、分页查询等多个方面的复杂问题。通过理解和掌握这些知识点，我们可以有效地提高数据库操作的效率和系统的响应速度。
java 多线程内容 1. 线程概念 2. 线程的创建和停止 3. 线程的状态
08-14
java 多线程内容 1. 线程概念 2. 线程的创建和停止 3. 线程的状态
java进阶9——线程
bsw451926392的博客
02-26 293
多线程的概述 进程： 电脑中，一个正在运行的应用程序就是一个进程，如QQ,微信等 线程： 一个进程中可以只有一个线程，也可以包含许多个线程 多线程： 就是一个正在运行的程序中的多个线程同时在执行 线程实现 以下四种皆可实现线程 继承Thread类 构造方法： Thread(); // 创建一个线程 Thread(String name); // 创建一个...
java -9多线程Lock锁
imxlw00的专栏
12-29 230
虽然我们可以理解同步代码块和同步方法的锁对象问题，但是我们并没有直接看到在哪里加上了锁，在哪里释放了锁， 为了更清晰的表达如何加锁和释放锁,JDK5以后提供了一个新的锁对象Lock。 Lock是个接口。 void lock()： 获取锁。 void unlock():释放锁。 ReentrantLock是Lock的实现类。 public class SellTicket implements ...
Java之多线程
fighting
06-15 254
Java基础9（多线程） 1 多线程相关的概念 程序：是为了完成某个特定的任务，使用各种语言编写的指令集合是静态的。 进程：是一次程序执行的状态，或者正在运行的程序是动态的。它对应着从代码加载，执行至执行完毕的一个完整的过程，是一个动态的实体，它有自己的生命 线程：进程的进一步细化的线程，也是程序内部执行的一条路径。线程只...
【Java多线程学习】ScheduledThreadPoolExecutor源码解读
elricboa的专栏
12-20 556
背景 Timer的优点在于简单易用，但是由于所有的任务都是由同一个线程来调度，因此所有的任务都是串行执行的，同一时间只能有一个任务在执行，在前一个任务的延时都会影响到之后的任务。同时，Timer不会捕获TimerTask的异常，只是简单的停止，这样也肯定会影响到之后任务的执行。当然可以为了完成多线程适应多个Timer，只是这些Timer需要自己来管理，而不是一个框架体系。 鉴于
Java多线程学习（吐血超详细总结）
Gabriel的专栏
06-15 7万+
转自：http://www.mamicode.com/info-detail-517008.html 目录(?)[-] 一扩展javalangThread类二实现javalangRunnable接口三Thread和Runnable的区别四线程状态转换五线程调度六常用函数说明 使用方式为什么要用join方法 七常见线程名词解释八线程同步九线程数据传递      本文主要
springboot企业合同管理系统设计与实现 _毕业论文和ppt答辩稿.zip
最新发布
08-17
springboot企业合同管理系统设计与实现 _毕业论文和ppt答辩稿.zip
记单词应用demo，以此为基础可以改正成其他新型单词记忆APP
08-17
记单词应用demo，以此为基础可以改正成其他新型单词记忆APP
基于Master-Worker进程模型调度系统，Python3实现
08-17
基于Master-Worker进程模型调度系统，Python3实现
深入探究java.util.concurrent多线程编程实践
Java多线程并发编程是Java编程中一个非常重要的部分，主要涉及到的是在多处理器或多核处理器上实现应用程序的多线程。Java的多线程并发编程可以有效地利用计算机的多核处理器资源，提升程序的运行效率，尤其适用于...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值