如何创建线程?

Java并发编程:如何创建线程?

  在前面一篇文章中已经讲述了在进程和线程的由来,今天就来讲一下在Java中如何创建线程,让线程去执行一个子任务。下面先讲述一下Java中的应用程序和进程相关的概念知识,然后再阐述如何创建线程以及如何创建进程。下面是本文的目录大纲:

  一.Java中关于应用程序和进程相关的概念

  二.Java中如何创建线程

  三.Java中如何创建进程

  若有不正之处,请多多谅解并欢迎批评指正。

  请尊重作者劳动成果,转载请标明原文链接:

   http://www.cnblogs.com/dolphin0520/p/3913517.html

一.Java中关于应用程序和进程相关的概念

  在Java中,一个应用程序对应着一个JVM实例(也有地方称为JVM进程),一般来说名字默认为java.exe或者javaw.exe(windows下可以通过任务管理器查看)。Java采用的是单线程编程模型,即在我们自己的程序中如果没有主动创建线程的话,只会创建一个线程,通常称为主线程。但是要注意,虽然只有一个线程来执行任务,不代表JVM中只有一个线程,JVM实例在创建的时候,同时会创建很多其他的线程(比如垃圾收集器线程)。

  由于Java采用的是单线程编程模型,因此在进行UI编程时要注意将耗时的操作放在子线程中进行,以避免阻塞主线程(在UI编程时,主线程即UI线程,用来处理用户的交互事件)。

二.Java中如何创建线程

  在java中如果要创建线程的话,一般有两种方式:1)继承Thread类;2)实现Runnable接口。

  1.继承Thread类

  继承Thread类的话,必须重写run方法,在run方法中定义需要执行的任务。

1
2
3
4
5
6
7
8
9
10
11
12
class MyThread extends Thread{
    private static int num = 0;
     
    public MyThread(){
        num++;
    }
     
    @Override
    public void run() {
        System.out.println("主动创建的第"+num+"个线程");
    }
}

   创建好了自己的线程类之后,就可以创建线程对象了,然后通过start()方法去启动线程。注意,不是调用run()方法启动线程,run方法中只是定义需要执行的任务,如果调用run方法,即相当于在主线程中执行run方法,跟普通的方法调用没有任何区别,此时并不会创建一个新的线程来执行定义的任务。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
public class Test {
    public static void main(String[] args)  {
        MyThread thread = new MyThread();
        thread.start();
    }
}
class MyThread extends Thread{
    private static int num = 0;
     
    public MyThread(){
        num++;
    }
     
    @Override
    public void run() {
        System.out.println("主动创建的第"+num+"个线程");
    }
}

   在上面代码中,通过调用start()方法,就会创建一个新的线程了。为了分清start()方法调用和run()方法调用的区别,请看下面一个例子:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
public class Test {
    public static void main(String[] args)  {
        System.out.println("主线程ID:"+Thread.currentThread().getId());
        MyThread thread1 = new MyThread("thread1");
        thread1.start();
        MyThread thread2 = new MyThread("thread2");
        thread2.run();
    }
}
class MyThread extends Thread{
    private String name;
     
    public MyThread(String name){
        this.name = name;
    }
     
    @Override
    public void run() {
        System.out.println("name:"+name+" 子线程ID:"+Thread.currentThread().getId());
    }
}

   运行结果:

  从输出结果可以得出以下结论:

  1)thread1和thread2的线程ID不同,thread2和主线程ID相同,说明通过run方法调用并不会创建新的线程,而是在主线程中直接运行run方法,跟普通的方法调用没有任何区别;

  2)虽然thread1的start方法调用在thread2的run方法前面调用,但是先输出的是thread2的run方法调用的相关信息,说明新线程创建的过程不会阻塞主线程的后续执行。

  2.实现Runnable接口

  在Java中创建线程除了继承Thread类之外,还可以通过实现Runnable接口来实现类似的功能。实现Runnable接口必须重写其run方法。

下面是一个例子:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
public class Test {
    public static void main(String[] args)  {
        System.out.println("主线程ID:"+Thread.currentThread().getId());
        MyRunnable runnable = new MyRunnable();
        Thread thread = new Thread(runnable);
        thread.start();
    }
}
class MyRunnable implements Runnable{
     
    public MyRunnable() {
         
    }
     
    @Override
    public void run() {
        System.out.println("子线程ID:"+Thread.currentThread().getId());
    }
}

   Runnable的中文意思是“任务”,顾名思义,通过实现Runnable接口,我们定义了一个子任务,然后将子任务交由Thread去执行。注意,这种方式必须将Runnable作为Thread类的参数,然后通过Thread的start方法来创建一个新线程来执行该子任务。如果调用Runnable的run方法的话,是不会创建新线程的,这根普通的方法调用没有任何区别。

  事实上,查看Thread类的实现源代码会发现Thread类是实现了Runnable接口的。

  在Java中,这2种方式都可以用来创建线程去执行子任务,具体选择哪一种方式要看自己的需求。直接继承Thread类的话,可能比实现Runnable接口看起来更加简洁,但是由于Java只允许单继承,所以如果自定义类需要继承其他类,则只能选择实现Runnable接口。

三.Java中如何创建进程

   在Java中,可以通过两种方式来创建进程,总共涉及到5个主要的类。

  第一种方式是通过Runtime.exec()方法来创建一个进程,第二种方法是通过ProcessBuilder的start方法来创建进程。下面就来讲一讲这2种方式的区别和联系。

  首先要讲的是Process类,Process类是一个抽象类,在它里面主要有几个抽象的方法,这个可以通过查看Process类的源代码得知:

  位于java.lang.Process路径下:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
public abstract class Process
{
    
    abstract public OutputStream getOutputStream();   //获取进程的输出流
      
    abstract public InputStream getInputStream();    //获取进程的输入流
    abstract public InputStream getErrorStream();   //获取进程的错误流
    abstract public int waitFor() throws InterruptedException;   //让进程等待
  
    abstract public int exitValue();   //获取进程的退出标志
    abstract public void destroy();   //摧毁进程
}

  1)通过ProcessBuilder创建进程

  ProcessBuilder是一个final类,它有两个构造器:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
public final class ProcessBuilder
{
    private List<String> command;
    private File directory;
    private Map<String,String> environment;
    private boolean redirectErrorStream;
    public ProcessBuilder(List<String> command) {
    if (command == null)
        throw new NullPointerException();
    this.command = command;
    }
    public ProcessBuilder(String... command) {
    this.command = new ArrayList<String>(command.length);
    for (String arg : command)
        this.command.add(arg);
    }
....
}

   构造器中传递的是需要创建的进程的命令参数,第一个构造器是将命令参数放进List当中传进去,第二构造器是以不定长字符串的形式传进去。

  那么我们接着往下看,前面提到是通过ProcessBuilder的start方法来创建一个新进程的,我们看一下start方法中具体做了哪些事情。下面是start方法的具体实现源代码:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
public Process start() throws IOException {
// Must convert to array first -- a malicious user-supplied
// list might try to circumvent the security check.
String[] cmdarray = command.toArray(new String[command.size()]);
for (String arg : cmdarray)
    if (arg == null)
    throw new NullPointerException();
// Throws IndexOutOfBoundsException if command is empty
String prog = cmdarray[0];
SecurityManager security = System.getSecurityManager();
if (security != null)
    security.checkExec(prog);
String dir = directory == null null : directory.toString();
try {
    return ProcessImpl.start(cmdarray,
                 environment,
                 dir,
                 redirectErrorStream);
catch (IOException e) {
    // It's much easier for us to create a high-quality error
    // message than the low-level C code which found the problem.
    throw new IOException(
    "Cannot run program \"" + prog + "\""
    + (dir == null "" " (in directory \"" + dir + "\")")
    ": " + e.getMessage(),
    e);
}
}

   该方法返回一个Process对象,该方法的前面部分相当于是根据命令参数以及设置的工作目录进行一些参数设定,最重要的是try语句块里面的一句:

1
2
3
4
return ProcessImpl.start(cmdarray,
                    environment,
                    dir,
                    redirectErrorStream);

   说明真正创建进程的是这一句,注意调用的是ProcessImpl类的start方法,此处可以知道start必然是一个静态方法。那么ProcessImpl又是什么类呢?该类同样位于java.lang.ProcessImpl路径下,看一下该类的具体实现:

  ProcessImpl也是一个final类,它继承了Process类:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
final class ProcessImpl extends Process {
    // System-dependent portion of ProcessBuilder.start()
    static Process start(String cmdarray[],
             java.util.Map<String,String> environment,
             String dir,
             boolean redirectErrorStream)
    throws IOException
    {
    String envblock = ProcessEnvironment.toEnvironmentBlock(environment);
    return new ProcessImpl(cmdarray, envblock, dir, redirectErrorStream);
    }
 ....
}

   这是ProcessImpl类的start方法的具体实现,而事实上start方法中是通过这句来创建一个ProcessImpl对象的:

1
return new ProcessImpl(cmdarray, envblock, dir, redirectErrorStream);

   而在ProcessImpl中对Process类中的几个抽象方法进行了具体实现。

  说明事实上通过ProcessBuilder的start方法创建的是一个ProcessImpl对象。

  下面看一下具体使用ProcessBuilder创建进程的例子,比如我要通过ProcessBuilder来启动一个进程打开cmd,并获取ip地址信息,那么可以这么写:

1
2
3
4
5
6
7
8
9
10
11
12
public class Test {
    public static void main(String[] args) throws IOException  {
        ProcessBuilder pb = new ProcessBuilder("cmd","/c","ipconfig/all");
        Process process = pb.start();
        Scanner scanner = new Scanner(process.getInputStream());
         
        while(scanner.hasNextLine()){
            System.out.println(scanner.nextLine());
        }
        scanner.close();
    }
}

   第一步是最关键的,就是将命令字符串传给ProcessBuilder的构造器,一般来说,是把字符串中的每个独立的命令作为一个单独的参数,不过也可以按照顺序放入List中传进去。

  至于其他很多具体的用法不在此进行赘述,比如通过ProcessBuilder的environment方法和directory(File directory)设置进程的环境变量以及工作目录等,感兴趣的朋友可以查看相关API文档。

  2)通过Runtime的exec方法来创建进程

  首先还是来看一下Runtime类和exec方法的具体实现,Runtime,顾名思义,即运行时,表示当前进程所在的虚拟机实例。

  由于任何进程只会运行于一个虚拟机实例当中,所以在Runtime中采用了单例模式,即只会产生一个虚拟机实例:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
public class Runtime {
    private static Runtime currentRuntime = new Runtime();
    /**
     * Returns the runtime object associated with the current Java application.
     * Most of the methods of class <code>Runtime</code> are instance
     * methods and must be invoked with respect to the current runtime object.
     *
     * @return  the <code>Runtime</code> object associated with the current
     *          Java application.
     */
    public static Runtime getRuntime() {
    return currentRuntime;
    }
    /** Don't let anyone else instantiate this class */
    private Runtime() {}
    ...
 }

   从这里可以看出,由于Runtime类的构造器是private的,所以只有通过getRuntime去获取Runtime的实例。接下来着重看一下exec方法 实现,在Runtime中有多个exec的不同重载实现,但真正最后执行的是这个版本的exec方法:

1
2
3
4
5
6
7
public Process exec(String[] cmdarray, String[] envp, File dir)
   throws IOException {
   return new ProcessBuilder(cmdarray)
       .environment(envp)
       .directory(dir)
       .start();
   }

   可以发现,事实上通过Runtime类的exec创建进程的话,最终还是通过ProcessBuilder类的start方法来创建的。

  下面看一个例子,看一下通过Runtime的exec如何创建进程,还是前面的例子,调用cmd,获取ip地址信息:

1
2
3
4
5
6
7
8
9
10
11
12
public class Test {
    public static void main(String[] args) throws IOException  {
        String cmd = "cmd "+"/c "+"ipconfig/all";
        Process process = Runtime.getRuntime().exec(cmd);
        Scanner scanner = new Scanner(process.getInputStream());
         
        while(scanner.hasNextLine()){
            System.out.println(scanner.nextLine());
        }
        scanner.close();
    }
}

   要注意的是,exec方法不支持不定长参数(ProcessBuilder是支持不定长参数的),所以必须先把命令参数拼接好再传进去。

  关于在Java中如何创建线程和进程的话,暂时就讲这么多了,感兴趣的朋友可以参考相关资料、

  参考资料:

  http://luckykapok918.blog.163.com/blog/static/205865043201210272168556/

  http://www.cnblogs.com/ChrisWang/archive/2009/12/02/use-java-lang-process-and-processbuilder-to-create-native-application-process.html

  http://lavasoft.blog.51cto.com/62575/15662/

  《Java编程思想》

   

转载于:https://www.cnblogs.com/daxiong225/p/8975343.html

本文来自互联网用户投稿,该文观点仅代表作者本人,不代表本站立场。本站仅提供信息存储空间服务,不拥有所有权,不承担相关法律责任。如若转载,请注明出处:http://www.mzph.cn/news/367108.shtml

如若内容造成侵权/违法违规/事实不符,请联系多彩编程网进行投诉反馈email:809451989@qq.com,一经查实,立即删除!

相关文章

经典MapReduce作业和Yarn上MapReduce作业运行机制

一、经典MapReduce的作业运行机制 如下图是经典MapReduce作业的工作原理&#xff1a; 1.1 经典MapReduce作业的实体 经典MapReduce作业运行过程包含的实体&#xff1a; 客户端&#xff0c;提交MapReduce作业。JobTracker&#xff0c;协调作业的运行。JobTracker是一个Java应用程…

根据Linux2.6.26源码分析进程模型

1.关于进程 1.1进程的概念 进程是正在运行的程序实体&#xff0c;并且包括这个运行的程序中占据的所有系统资源&#xff0c;比如说CPU(寄存器)&#xff0c;IO,内存&#xff0c;网络资源等。很多人在回答进程的概念的时候&#xff0c;往往只会说它是一个运行的实体&#xff0c;而…

socket编程开发

1.socket是什么&#xff1f; Socket是应用层与TCP/IP协议族通信的中间软件抽象层&#xff0c;它是一组接口。在设计模式中&#xff0c;Socket其实就是一个门面模式&#xff0c; 它把复杂的TCP/IP协议族隐藏在Socket接口后面&#xff0c;对用户来说&#xff0c;一组简单的接口就…

一个前端岗位电话面试所带来的问题的思考

这绝对不是一篇技术文&#xff0c;如果你不喜欢&#xff0c;也请不要喷&#xff0c;你可以看看都有哪些问题&#xff0c;当然&#xff0c;在这里你可能得不到问题的答案&#xff0c;不懂的你可能需要自己去百度&#xff0c;也可以在下面留言交流&#xff0c;我已经声明了&#…

Spring MVC –揭秘了@RequestBody和@ResponseBody

在这篇文章中&#xff0c;我想对Spring MVC进行一些深入的探讨&#xff0c;以揭示将请求转换为参数对象后在幕后发生的情况&#xff0c;反之亦然。 在开始之前&#xff0c;我想解释这些注释的目的。 RequestBody和ResponseBody是做什么用的&#xff1f; 它们是spring mvc框架的…

python大作业外星人入侵_【python3小白上路系列】外星人入侵——开始

早起的周日&#xff0c;今日阴天&#xff0c;老爸生日快乐~开始项目首先创建一个空的Pygame窗口&#xff0c;供后面用来绘制游戏元素&#xff0c;如飞船和外星人。我们还将让这个游戏响应用户输入、设置背景色以及加载飞船图像。1.1.1 创建Pygame窗口以及相应用户输入首先&…

Codeforces 975D Ghosts 【math】

打了两次cf里的比赛&#xff0c;发现cf比较喜欢考数学题。一开始看到这道题没有思路&#xff0c;因为总想dp&#xff0c;图论&#xff0c;贪心这些东西。如果下次再没有思路&#xff0c;可以从数学的角度入手。 题解说的比较清楚&#xff1a; 2018.9.4又看了遍这题&#xff0c;…

前后台分离之数据模拟

在前后端分离的项目中&#xff0c;前后端约定好接口以后&#xff0c;就开始进入各自的开发阶段了&#xff0c;这时候我们前端不可避免的就需要进行数据模拟&#xff0c;那么怎么进行数据模拟呢&#xff1f;我觉得有两种&#xff1a; 在 客户端 模拟数据&#xff0c;也就是在我…

碎玻璃:诊断生产Cassandra问题

我刚刚在健康市场科学&#xff08;HMS&#xff09;成立二周年之际&#xff0c;我们几乎一直在这里与Cassandra一起工作。 那时&#xff0c;我们遇到的问题很少。 就像我曾经使用过的其他几种技术一样&#xff0c;Cassandra“行之有效”。 但是&#xff0c;就像我曾经使用过的*…

java 一维数组_java基础 ---- 一维数组

为什么要使用数组&#xff1a; 因为不使用数组计算多个变量的时候太繁琐&#xff0c;不利于数据的处理。-------- 数组也是一个变量&#xff0c;是存储一组相同类型的变量声明一个变量就是在内存中划出一块合适的空间声明一个数组就是在内存中划出一块连续的空间数组长度就是…

四则运算2

作业描述&#xff1a; 悲催的二柱子接到了老师要求给软件增加一些小小的功能&#xff0c;具体要求如下&#xff1a; 1、除了整数以外&#xff0c;还要支持真分数的四则运算&#xff08;需要验证结果的正确性&#xff09;&#xff1b; 2、一次出的题目避免相互重复&#xff1b; …

Java中的策略设计模式-示例教程

策略模式是行为设计模式之一 。 当我们对一个特定任务有多种算法&#xff0c;并且客户端决定在运行时使用的实际实现时&#xff0c;将使用策略模式。 策略模式也称为策略模式 。 我们定义了多种算法&#xff0c;并让客户端应用程序将算法用作参数。 此模式的最佳示例之一是采用…

MySQL数据库主从复制

使用gtid &#xff08;也需要开启binlog日志&#xff09; CHANGE MASTER TO MASTER_HOST’192.168.95.11’, MASTER_USER’mysql12’, MASTER_PASSWORD’mysql12’,MASTER_AUTO_POSITION 1; 使用binlog CHANGE MASTER TO MASTER_HOST’192.168.95.12’, MASTER_USER’mysql…

vue-cli 3.0 使用全过程讲解

2018年8月13日更新&#xff1a; 恭祝vue-cli 3.0.0 官方正式版发布&#xff0c;此后我们可以正式在3.0环境下进行项目开发了。 此文发布以来受到了很多朋友的阅读&#xff0c;但我深知这篇文章还是很浅显的&#xff0c;因此&#xff0c;我会在后续的 3.0 使用过程中分享我遇到…

java反射机制在spring_Java反射机制在Spring IOC中的应用

IOC&#xff1a;即“控制反转”&#xff0c;不是什么技术&#xff0c;而是一种思想。使用IOC意味着将你设计好的对象交给容器控制&#xff0c;而不是传统的在你的对象内部直接控制。本篇文章主要讲解一下IOC底层实现的原理(反射)&#xff0c;Bean容器的实现&#xff0c;就不对I…

【图像处理】Haar-like特征

特征提取的原理、代码等&#xff1b; 如果是白黑白&#xff0c;是减去一个黑的还是2个黑的&#xff0c;网上有不同的说法&#xff1b;应该需要看原论文了。 论文原文 The sum of the pixels which lie within the white rectangles are subtracted from the sum of pixels in t…

mysql获取某个表的所有字段名

转载&#xff1a;mym43210 mysql安装成功后可以看到已经存在mysql、information_schema和test这个几个数据库。 information_schema库中有一个名为COLUMNS的表&#xff0c;这个表中记录了数据库中所有表的字段信息。 知道这个表后&#xff0c;获取任意表的字段就只需要一条sele…

neo4j / cypher:悬挂查询参数

一直以来&#xff0c;我一直在使用neo4j的密码查询语言&#xff0c; 迈克尔一直在告诉我在查询中使用参数&#xff0c;但是查询的性能始终可以接受&#xff0c;因此我没有必要。 但是&#xff0c;最近我正在研究一个数据集&#xff0c;并使用类似于以下的代码创建了约500个节点…

java调用浏览器组件来_Java 网页浏览器组件介绍

在使用 Java 开发客户端程序时&#xff0c;有时会需要在界面中使用网页浏览器组件&#xff0c;用来显示一段 HTML 或者一个特定的网址。本文将介绍在界面中使用浏览器组件的四种方法&#xff0c;给出示例的代码&#xff0c;并且分析每种方法的优点与不足&#xff0c;便于 Java …

前端入行两年--教会了我这些道理

1.前言 光阴似箭&#xff0c;日月如梭。不得不感慨时间过得很快&#xff0c;2017差不多结束了&#xff0c;一下子我从事前端开发的时间已经两年了。这两年可以说是一波三折&#xff0c;回想这两年的经历&#xff0c;让我忍不住了写下了这篇文章&#xff0c;记录自己在这两年经历…