编程思想之多线程与多进程(3)——Java中的多线程

最新推荐文章于 2023-11-05 15:58:20 发布
最新推荐文章于 2023-11-05 15:58:20 发布
阅读量1.8w 收藏 73
点赞数 21
分类专栏： java 编程思想 编程思想 文章标签： Java 多线程 线程同步 编程思想
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/luoweifu/article/details/46673975
版权
java 同时被 3 个专栏收录
35 篇文章 7 订阅
订阅专栏
编程思想
26 篇文章 18 订阅
订阅专栏
编程思想
22 篇文章 158 订阅
订阅专栏

原文：http://blog.csdn.net/luoweifu/article/details/46673975
作者:luoweifu
转载请标名出处

《编程思想之多线程与多进程(1)——以操作系统的角度述说线程与进程》一文详细讲述了线程、进程的关系及在操作系统中的表现，这是多线程学习必须了解的基础。本文将接着讲一下Java中多线程程序的开发

单线程

任何程序至少有一个线程，即使你没有主动地创建线程，程序从一开始执行就有一个默认的线程，被称为主线程，只有一个线程的程序称为单线程程序。如下面这一简单的代码，没有显示地创建一个线程，程序从main开始执行，main本身就是一个线程(主线程)，单个线程从头执行到尾。

【Demo1】：单线程程序

public static void main(String args[]) {
   System.out.println("输出从1到100的数:");
   for (int i = 0; i < 100; i ++) {
      System.out.println(i + 1);
   }
}

创建线程

单线程程序简单明了，但有时无法满足特定的需求。如一个文字处理的程序，我在打印文章的同时也要能对文字进行编辑，如果是单线程的程序则要等打印机打印完成之后你才能对文字进行编辑，但打印的过程一般比较漫长，这是我们无法容忍的。如果采用多线程，打印的时候可以单独开一个线程去打印，主线程可以继续进行文字编辑。在程序需要同时执行多个任务时，可以采用多线程。

在程序需要同时执行多个任务时，可以采用多线程。Java给多线程编程提供了内置的支持，提供了两种创建线程方法：1.通过实现Runable接口；2.通过继承Thread类。

Thread是JDK实现的对线程支持的类，Thread类本身实现了Runnable接口，所以Runnable是显示创建线程必须实现的接口; Runnable只有一个run方法，所以不管通过哪种方式创建线程，都必须实现run方法。我们可以看一个例子。

【Demo2】：线程的创建和使用

/**
 * Created with IntelliJ IDEA.
 * User: luoweifu
 * Date: 15-5-24
 * Time: 下午9:30
 * To change this template use File | Settings | File Templates.
 */

/**
 * 通过实现Runnable方法
 */
class ThreadA implements Runnable {
   private Thread thread;
   private String threadName;
   public ThreadA(String threadName) {
      thread = new Thread(this, threadName);
      this.threadName = threadName;
   }

   //实现run方法
   public void run() {
      for (int i = 0; i < 100; i ++) {
         System.out.println(threadName + ": " + i);
      }
   }

   public void start() {
      thread.start();
   }
}

/**
 * 继承Thread的方法
 */
class ThreadB extends Thread {
   private String threadName;

   public ThreadB(String threadName) {
      super(threadName);
      this.threadName = threadName;
   }

   //实现run方法
   public void run() {
      for (int i = 0; i < 100; i ++) {
         System.out.println(threadName + ": " + i);
      }
   }
}

public class MultiThread{

   public static void main(String args[]) {
      ThreadA threadA = new ThreadA("ThreadA");
      ThreadB threadB = new ThreadB("ThreadB");
      threadA.start();
      threadB.start();
   }
}

说明：上面的例子中例举了两种实现线程的方式。大部分情况下选择实现Runnable接口的方式会优于继承Thread的方式，因为：
1. 从 Thread 类继承会强加类层次；
2. 有些类不能继承Thread类，如要作为线程运行的类已经是某一个类的子类了，但Java只支持单继承，所以不能再继承Thread类了。

线程同步

线程与线程之间的关系，有几种:

模型一：简单的线程，多个线程同时执行，但各个线程处理的任务毫不相干，没有数据和资源的共享，不会出现争抢资源的情况。这种情况下不管有多少个线程同时执行都是安全的，其执行模型如下：

处理相互独立的任务
图 1：处理相互独立的任务

模型二：复杂的线程，多个线程共享相同的数据或资源，就会出现多个线程争抢一个资源的情况。这时就容易造成数据的非预期(错误)处理，是线程不安全的，其模型如下:

多个线程共享相同的数据或资源
图 2：多个线程共享相同的数据或资源

在出现模型二的情况时就要考虑线程的同步，确保线程的安全。Java中对线程同步的支持，最常见的方式是添加synchronized同步锁。

我们通过一个例子来看一下线程同步的应用。

买火车票是大家春节回家最为关注的事情，我们就简单模拟一下火车票的售票系统(为使程序简单，我们就抽出最简单的模型进行模拟)：有500张从北京到赣州的火车票，在8个窗口同时出售，保证系统的稳定性和数据的原子性。

模拟火车票售票系统
图 3：模拟火车票售票系统

【Demo3】：火车票售票系统模拟程序

/**
 * 模拟服务器的类
 */
class Service {
   private String ticketName;    //票名
   private int totalCount;        //总票数
   private int remaining;        //剩余票数

   public Service(String ticketName, int totalCount) {
      this.ticketName = ticketName;
      this.totalCount = totalCount;
      this.remaining = totalCount;
   }

   public synchronized int saleTicket(int ticketNum) {
      if (remaining > 0) {
         remaining -= ticketNum;
         try {        //暂停0.1秒，模拟真实系统中复杂计算所用的时间
            Thread.sleep(100);
         } catch (InterruptedException e) {
            e.printStackTrace();
         }

         if (remaining >= 0) {
            return remaining;
         } else {
            remaining += ticketNum;
            return -1;
         }
      }
      return -1;
   }

   public synchronized int getRemaining() {
      return remaining;
   }

   public String getTicketName() {
      return this.ticketName;
   }

}

/**
 * 售票程序
 */
class TicketSaler implements Runnable {
   private String name;
   private Service service;

   public TicketSaler(String windowName, Service service) {
      this.name = windowName;
      this.service = service;
   }

   @Override
   public void run() {
      while (service.getRemaining() > 0) {
         synchronized (this)
         {
            System.out.print(Thread.currentThread().getName() + "出售第" + service.getRemaining() + "张票，");
            int remaining = service.saleTicket(1);
            if (remaining >= 0) {
               System.out.println("出票成功!剩余" + remaining + "张票.");
            } else {
               System.out.println("出票失败！该票已售完。");
            }
         }
      }
   }
}

测试程序：

/**
 * 测试类
 */
public class TicketingSystem {
   public static void main(String args[]) {
      Service service = new Service("北京-->赣州", 500);
      TicketSaler ticketSaler = new TicketSaler("售票程序", service);
      //创建8个线程，以模拟8个窗口
      Thread threads[] = new Thread[8];
      for (int i = 0; i < threads.length; i++) {
         threads[i] = new Thread(ticketSaler, "窗口" + (i + 1));
         System.out.println("窗口" + (i + 1) + "开始出售 " + service.getTicketName() + " 的票...");
         threads[i].start();
      }

   }
}

结果如下：

窗口1开始出售 北京–>赣州 的票…
窗口2开始出售 北京–>赣州 的票…
窗口3开始出售 北京–>赣州 的票…
窗口4开始出售 北京–>赣州 的票…
窗口5开始出售 北京–>赣州 的票…
窗口6开始出售 北京–>赣州 的票…
窗口7开始出售 北京–>赣州 的票…
窗口8开始出售 北京–>赣州 的票…
窗口1出售第500张票，出票成功!剩余499张票.
窗口1出售第499张票，出票成功!剩余498张票.
窗口6出售第498张票，出票成功!剩余497张票.
窗口6出售第497张票，出票成功!剩余496张票.
窗口1出售第496张票，出票成功!剩余495张票.
窗口1出售第495张票，出票成功!剩余494张票.
窗口1出售第494张票，出票成功!剩余493张票.
窗口2出售第493张票，出票成功!剩余492张票.
窗口2出售第492张票，出票成功!剩余491张票.
窗口2出售第491张票，出票成功!剩余490张票.
窗口2出售第490张票，出票成功!剩余489张票.
窗口2出售第489张票，出票成功!剩余488张票.
窗口2出售第488张票，出票成功!剩余487张票.
窗口6出售第487张票，出票成功!剩余486张票.
窗口6出售第486张票，出票成功!剩余485张票.
窗口3出售第485张票，出票成功!剩余484张票.
……

在上面的例子中，涉及到数据的更改的Service类saleTicket方法和TicketSaler类run方法都用了synchronized同步锁进行同步处理，以保证数据的准确性和原子性。

关于synchronized更详细的用法请参见：《Java中Synchronized的用法》

线程控制

在多线程程序中，除了最重要的线程同步外，还有其它的线程控制，如线程的中断、合并、优先级等。

线程等待(wait、notify、notifyAll)

Wait：使当前的线程处于等待状态；
Notify：唤醒其中一个等待线程；
notifyAll：唤醒所有等待线程。

详细用法参见：《 Java多线程中wait, notify and notifyAll的使用》

线程中断(interrupt)

在Java提供的线程支持类Thread中，有三个用于线程中断的方法：
public void interrupt(); 中断线程。
public static boolean interrupted(); 是一个静态方法，用于测试当前线程是否已经中断，并将线程的中断状态 清除。所以如果线程已经中断，调用两次interrupted，第二次时会返回false，因为第一次返回true后会清除中断状态。
public boolean isInterrupted(); 测试线程是否已经中断。

【Demo4】：线程中断的应用

/**
 * 打印线程
 */
class Printer implements Runnable {
   public void run() {
      while (!Thread.currentThread().isInterrupted()) {     //如果当前线程未被中断，则执行打印工作
         System.out.println(Thread.currentThread().getName() + "打印中… …");
      }
      if (Thread.currentThread().isInterrupted()) {
         System.out.println("interrupted:" +  Thread.interrupted());       //返回当前线程的状态，并清除状态
         System.out.println("isInterrupted:" +  Thread.currentThread().isInterrupted());
      }
   }
}

调用代码：

Printer printer = new Printer();
Thread printerThread = new Thread(printer, "打印线程");
printerThread.start();
try {
   Thread.sleep(100);
} catch (InterruptedException e) {
   e.printStackTrace();
}
System.out.println("有紧急任务出现，需中断打印线程.");
System.out.println("中断前的状态：" + printerThread.isInterrupted());
printerThread.interrupt();       // 中断打印线程
System.out.println("中断前的状态：" + printerThread.isInterrupted());

结果：

打印线程打印中… …
… …
打印线程打印中… …
有紧急任务出现，需中断打印线程.
打印线程打印中… …
中断前的状态：false
打印线程打印中… …
中断前的状态：true
interrupted:true
isInterrupted:false

线程合并(join)

所谓合并，就是等待其它线程执行完，再执行当前线程，执行起来的效果就好像把其它线程合并到当前线程执行一样。其执行关系如下：

线程合并的过程
图 4:线程合并的过程

public final void join()
等待该线程终止

public final void join(long millis);
等待该线程终止的时间最长为 millis 毫秒。超时为 0 意味着要一直等下去。

public final void join(long millis, int nanos)
等待该线程终止的时间最长为 millis 毫秒 + nanos 纳秒

这个常见的一个应用就是安装程序，很多大的软件都会包含多个插件，如果选择完整安装，则要等所有的插件都安装完成才能结束，且插件与插件之间还可能会有依赖关系。

【Demo5】:线程合并

/**
 * 插件1
 */
class Plugin1 implements Runnable {

   @Override
   public void run() {
      System.out.println("插件1开始安装.");
      System.out.println("安装中...");
      try {
         Thread.sleep(1000);
      } catch (InterruptedException e) {
         e.printStackTrace();
      }
      System.out.println("插件1完成安装.");
   }
}

/**
 * 插件2
 */
class Plugin2 implements Runnable {

   @Override
   public void run() {
      System.out.println("插件2开始安装.");
      System.out.println("安装中...");
      try {
         Thread.sleep(2000);
      } catch (InterruptedException e) {
         e.printStackTrace();
      }
      System.out.println("插件2完成安装.");
   }
}

合并线程的调用：

System.out.println("主线程开启...");
Thread thread1 = new Thread(new Plugin1());
Thread thread2 = new Thread(new Plugin2());
try {
   thread1.start();   //开始插件1的安装
   thread1.join();       //等插件1的安装线程结束
   thread2.start();   //再开始插件2的安装
   thread2.join();       //等插件2的安装线程结束,才能回到主线程
} catch (InterruptedException e) {
   e.printStackTrace();
}
System.out.println("主线程结束，程序安装完成！");

结果如下：

主线程开启…
插件1开始安装.
安装中…
插件1完成安装.
插件2开始安装.
安装中…
插件2完成安装.
主线程结束，程序安装完成！

优先级(Priority)

线程优先级是指获得CPU资源的优先程序。优先级高的容易获得CPU资源，优先级底的较难获得CPU资源，表现出来的情况就是优先级越高执行的时间越多。

Java中通过getPriority和setPriority方法获取和设置线程的优先级。Thread类提供了三个表示优先级的常量：MIN_PRIORITY优先级最低，为1；NORM_PRIORITY是正常的优先级；为5，MAX_PRIORITY优先级最高，为10。我们创建线程对象后，如果不显示的设置优先级的话，默认为5。

【Demo】:线程优先级

/**
 * 优先级
 */
class PriorityThread implements Runnable{
   @Override
   public void run() {
      for (int i = 0; i < 1000; i ++) {
         System.out.println(Thread.currentThread().getName() + ": " + i);
      }
   }
}

调用代码：

//创建三个线程
Thread thread1 = new Thread(new PriorityThread(), "Thread1");
Thread thread2 = new Thread(new PriorityThread(), "Thread2");
Thread thread3 = new Thread(new PriorityThread(), "Thread3");
//设置优先级
thread1.setPriority(Thread.MAX_PRIORITY);
thread2.setPriority(8);
//开始执行线程
thread3.start();
thread2.start();
thread1.start();

从结果中我们可以看到线程thread1明显比线程thread3执行的快。


如果您有什么疑惑和想法，请在评论处给予反馈，您的反馈就是最好的测评师！由于本人技术和能力有限，如果本博文有错误或不足之处，敬请谅解并给出您宝贵的建议！

原文：http://blog.csdn.net/luoweifu/article/details/46673975
作者:luoweifu
转载请标名出处


========================编程思想系列文章回顾========================
编程思想之多线程与多进程
编程思想之消息机制
编程思想之日志记录
编程思想之异常处理
编程思想之正则表达式
编程思想之迭代器
编程思想之递归
编程思想之回调

luoweifu
关注
  • 21
    点赞
  • 踩
  • 73
    收藏
    觉得还不错? 一键收藏
  • 4
    评论
专栏目录
java多线程编程之从线程返回数据的两种方法
09-04
从线程中返回数据和向线程传递数据类似。也可以通过类成员以及回调函数来返回数据。但类成员在返回数据和传递数据时有一些区别，下面让我们来看看它们区别在哪
c语言多进程多线程编程
07-21
c语言多进程多线程编程
python爬虫之多线程、多进程爬虫
02-24
多线程对爬虫的效率提高是非凡的，当我们使用python的多线程有几点是需要我们知道的：1.Python的多线程并不如java的多线程，其差异在于当python解释器开始执行任务时，受制于GIL(全局解释所)，Python的线程被限制到同一时刻只允许一个程执行这样一个执行模型。2.Python的线程更适用于处理I/O和其他需要并发行的阻塞操作（比如等待I/O、等待从数据库获取数据等等），而不是需要多处理器行的计算密集型任务。幸运的是,爬虫大部分时间在网络交互上，所以可以使用多线程来编写爬虫。3.这点其实和多线程关系不大，scrapy的并发并不是采用多线程来实现，它是一个twisted应用，通过异
编程思想之多线程与多进程共40页.pdf.zip
12-03
编程思想之多线程与多进程共40页.pdf.zip
python3 多线程入门
Critical_plus的博客
08-02 275
目录前言一、多线程简介二、使用线程的两种方法1.引入库2.读入数据总结 前言 此文，是我初学python3 多线程的学习记录，在下初学不久，理解比较浅薄，望各位大佬海涵。 一、多线程简介 我从python3开始接触多线程，并且还并没有接触其他语言的多线程操作，个人觉得应该不会有过多的差距，但没学习过之前不敢下判断。 在开发的实际工作中，时常遇到的问题之一便是，某一个事件需要一定时间的处理，但是又有其他的操作实际上不需要等待这个事件的处理结果。这样的单线操作，就导致的运行效率的低下。而解决这种问题的方
2. 初学Java多线程：用Thread类创建线程
蕃茄配黄瓜
07-08 483
在Java中创建线程有两种方法：使用Thread类和使用Runnable接口。任何一个Java程序都必须有一个主线程。学习Java多线程，需要先从用Thread类创建线程开始。         在Java中创建线程有两种方法：使用Thread类和使用Runnable接口。在使用R
【Java】创建线程的三种方式及Thread常用方法——Java多线程（一）
一顿输出
04-22 2536
一、创建线程的方式 方式一：继承Thread类 1）① 新建一个类，这个类继承了Thread，此时这个实现类就是一个线程类了。② 在线程类中重写Thread类的run()方法，重写的run方法中是线程类要执行的代码。③ 当要开启新线程时，调用线程类的start()方法。 2）注意： ① 主线程与子线程：java程序中的main方法称为主线程，在main方法中调用线程类来开启的线程称为子线程。 ② 调用线程类时，使用start()方法，而不能使用run()方法。虽然执行start()方法之后，线程类同样执行的
创建3个线程为Thread1Thread2Thread3 需要对一个数字进行递减操作 当数字递减到0的时候，输出“数字为0，结束递减”
王文强的博客
09-05 5215
多线程，对run方法内部进行一个同步运算。 以下是代码： package 一般测试题; public class 依次打印递增数字 { /** * 创建三个线程进行分段叠加 * 每个线程叠加四次 * */ public static void main(String[] args) { new Thread(new A...
假如有Thread1、Thread2、Thread3三条线程分别统计C、D、E三个盘的大小，所有线程都统计完毕交给Thread4线程去做汇总
m0_37882178的博客
03-14 1192
如题：有三种解决方法第一种是实现callable方法，重写call方法http://blog.csdn.net/silyvin/article/details/79235111我个人不想用这个方法，所以只贴了链接第二种方法：join方法创建3个线程Runnable r1 = new ThreadUtils("A"); Runnable r2 = new ThreadUtils("B"); Runn...
创建线程的三种方式
qq_30323473的博客
07-24 190
JAVA中创建线程的三种方式 1.继承Thread类创建线程 2.实现Runnable接口创建线程 3.线程池(使用callable和Future)创建线程 1.Thread package com.company.thread; import java.util.Random; /** * 使用继承Thread的方式实现多线程 * 创建一个比赛的类 */ public class Match { public static void main(String[] args) {
详解C#多线程编程之进程与线程
01-19
 简单来说，进程是对资源的抽象，是资源的容器，在传统操作系统中，进程是资源分配的基本单位，而且是执行的基本单位，进程支持并发执行，因为每个进程有独立的数据，独立的堆栈空间。一个程序想要并发执行，开多个...
头歌 实验七 Java线程
最新发布
weixin_55891853的博客
11-05 270
不管各线程的优先级及各线程sleep的时间，Thread1首先运行，获取数据后将数据存储在数据对象中，Thread2从数据对象中取值加10后存回数据对象，并输出；线程Thread1类继承类Gatherinfo，在Thread1类中直接调用Gatherinfo类中GetVal()方法获取采集的数据。实验已经定义了一个类Gatherinfo（如下），该类的GetVal()方法完成数据的生成。按要求完成Thread1、Thread2、Thread3类的编写。将数据存入数据对象中。返回数据对象中的数据。
如何控制多线程执行顺序
designerXie的博客
12-06 1452
前言：这道经典的面试题其实考察的是面试者对多线程API的了解程度。如果不考虑线程的API方法的话，自己脑路大开的话，方法其实很多种。今天我们就提两种最简单，也是最常用到的方法。 目标：建三个线程分别为thread1，thread2，thread3，让这三个线程依次执行。 首先，先来个多线程的实例： package main.java; public class App { static T...
JAVA多线程
weixin_43460927的博客
08-06 164
JAVA多线程 一、线程创建 在java中，线程用Thread类表示，所有的线程对象都是Thread类或子类的对象。 要想开发一个线程类，有两种方式： 1、继承Thread类，重写run方法。 首先开发我们的线程类，我们暂且称为这个类为A，类要继承Thread类。 重写Thread类的run方法。run方法就是你的线程要完成的功能。 创建A的实例，调用start方法启动这个线程。 注意这里不要调用run方法，如果调用run方法，就相当于run是一个普通方法，而不是线程了。一定通过Thread类的start方
创建线程的三种方法_多线程的创建三种方式
weixin_39761645的博客
12-11 664
一、多线程的简单理解明白什么是多线程，小生通俗一点的理解为：在一个程序里，我想同时让这个程序完成多个任务。比如：让主函数 main 在打印1~100之间的所有整数的时候，要求在主函数打印到 20 的时候，再运行另一个类里的程序，让它打印10~100之间的所有整数。这里忽略同进程内的多线程之间的抢占时间问题，上面的举例需求是要求一个程序只要有发生同时运行俩个程序的情况就行，即不准出现无论程...
头歌实验平台Java实验七
一只菜鸟呀的博客
11-01 1544
头歌实验平台Java实验六
java 创建线程thread_java线程之用Thread类创建线程的方法
weixin_42179184的博客
02-13 518
在Java中创建线程有两种方法：使用Thread类和使用Runnable接口。在使用Runnable接口时需要建立一个Thread实例。因此，无论是通过Thread类还是Runnable接口建立线程，都必须建立Thread类或它的子类的实例。Thread类的构造方法被重载了八次，构造方法如下：public Thread( );public Thread(Runnable target);publi...
Java多线程方法状态和创建（基础）
无极
09-02 224
Java之线程的五大状态及其常用方法（六个状态还有timed_wating超时等待） 1.线程的五大状态及其转换 线程的五大状态分别为：创建状态（New）、就绪状态（Runnable）、运行状态（Running）、阻塞状态（Blocked）、死亡状态（Dead）。 下面画出线程五大状态之间的关系图： （1）新建状态：即单纯地创建一个线程，创建线程有三种方式，在我的博客：线程的创建，可以自行查看！ （2）就绪状态：在创建了线程之后，调用Thread类的start()方法来启动一个线程，即表示线程进入就绪状态
java三种线程创建
qq_53127025的博客
05-13 709
1.继承Thread方法 2.实现Runnable接口 好处（避免单继承局限性，灵活方便，方便同一个对象被多个线程使用） 3.实现Callable接口 先看Thread方法 1.1继承Thread方法并重写run方法 public class Main extends Thread{ @Override public void run() { } } 1.2使用.start（）开启线程 Main main= new Main(); ..
c多进程编程模式与多线程编程模式
04-01
多进程编程模式和多线程编程模式都是一种并发编程的方式，用于提高程序的并发度和处理能力。 多进程编程模式是指在一个程序中启动多个进程并行运行，每个进程独立运行，有自己独立的内存空间和运行环境。多进程编程的优点是可以利用多个CPU核心并行处理任务，缺点是进程间通信比较复杂，需要使用IPC（进程间通信）技术，开销较大。 多线程编程模式是指在一个程序中启动多个线程并行运行，每个线程共享同一进程的内存空间和运行环境。多线程编程的优点是线程间通信比较简单，可以共享变量和资源，开销比进程间通信小，缺点是线程间竞争资源需谨慎处理，容易出现死锁等问题。 综上所述，多进程编程适用于处理密集型任务，如图像处理、数据分析等，多线程编程适用于处理I/O密集型任务，如网络编程、Web应用等。在实际应用中，可以根据具体情况选择合适的并发编程方式。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论 4
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值