并发编程专题(二)-线程的创建方式

1.创建多线程几种方式

1.1 继承Thread，重写父类的run()方法

Java使用java.lang.Thread类代表线程，所有的线程对象都必须是Thread类或其子类的实例。每个线程的作用是完成一定的任务，实际上就是执行一段程序流即一段顺序执行的代码。Java使用线程执行体来代表这段程序流。Java中通过继承Thread类来创建并启动多线程的步骤如下：

  1. 定义Thread类的子类，并重写该类的run()方法，该run()方法的方法体就代表了线程需要完成的任务,因此把run()方法称为线程执行体。
  2. 创建Thread子类的实例，即创建了线程对象
  3. 调用线程对象的start()方法来启动该线程

代码如下：

  • 自定义线程类

    /**
* @author bruceliu
* @create 2019-05-29 23:15
* @description 继承Thread，重写父类的run()方法
*/
public class MyThread extends Thread {

/*
 * 利用继承中的特点
 * 将线程名称传递 进行设置
 */
public MyThread(String name) {
    super(name);
}

/*
 * 重写run方法
 * 定义线程要执行的代码
 */
public void run() {
    for (int i = 0; i < 20; i++) {
        //getName()方法 来自父亲
        System.out.println(getName() + i);
    }
}
}
  • 测试类 
    /**
* @author bruceliu
* @create 2019-05-29 23:17
* @description 继承Thread，重写父类的run()方法
*/
public class TestMyThread {

public static void main(String[] args) {
    System.out.println("这里是main线程");
    MyThread mt = new MyThread("小强");
    mt.start();//开启了一个新的线程
    for (int i = 0; i < 20; i++) {
        System.out.println("旺财:"+i);
    }
}
}
  • 流程图

有可能有些人看不到这么明显的效果，这也很正常。所谓的多线程，指的是两个线程的代码可以同时运行，而不必一个线程需要等待另一个线程内的代码执行完才可以运行。对于单核CPU来说，是无法做到真正的多线程的，每个时间点上，CPU都会执行特定的代码，由于CPU执行代码时间很快，所以两个线程的代码交替执行看起来像是同时执行的一样。那具体执行某段代码多少时间，就和分时机制系统有关了。分时系统把CPU时间划分为多个时间片，操作系统以时间片为单位片为单位各个线程的代码，越好的CPU分出的时间片越小。所以看不到明显效果也很正常，一个线程打印5句话本来就很快，可能在分出的时间片内就执行完成了。所以，最简单的解决办法就是把for循环的值调大一点就可以了（也可以在for循环里加Thread.sleep方法，这个之后再说）。

1.2 实现Runnable接口,重写run方法

采用 java.lang.Runnable 也是非常常见的一种，我们只需要重写run方法即可。和继承自Thread类差不多，不过实现Runnable后，还是要通过一个Thread来启动：

  1. 定义Runnable接口的实现类，并重写该接口的run()方法，该run()方法的方法体同样是该线程的线程执行体。
  2. 创建Runnable实现类的实例，并以此实例作为Thread的target来创建Thread对象，该Thread对象才是真正
    的线程对象。
  3. 调用线程对象的start()方法来启动线程。

代码如下：

  • 自定义线程类

    /**
* @author bruceliu
* @create 2019-05-30 11:37
* @description 实现Runnable接口,重写run方法
*/
public class MyRunnable implements Runnable{
@Override
public void run() {
    for (int i = 0; i < 20; i++) {
        System.out.println(Thread.currentThread().getName()+" "+i);
    }
}
}
  • 线程测试类 
    /**
* @author bruceliu
* @create 2019-05-30 11:39
* @description 实现Runnable接口,重写run方法
*/
public class TestMyRunnable {

public static void main(String[] args) {
    //创建自定义类对象 线程任务对象
    MyRunnable mr = new MyRunnable();
    //创建线程对象
    Thread t = new Thread(mr, "小强");
    t.start();
    for (int i = 0; i < 20; i++) {
        System.out.println("旺财 " + i);
    }
}
}

    通过实现Runnable接口，使得该类有了多线程类的特征。run()方法是多线程程序的一个执行目标。所有的多线程代码都在run方法里面。Thread类实际上也是实现了Runnable接口的类。
    在启动的多线程的时候，需要先通过Thread类的构造方法Thread(Runnable target) 构造出对象，然后调用Thread对象的start()方法来运行多线程代码。
    实际上所有的多线程代码都是通过运行Thread的start()方法来运行的。因此，不管是继承Thread类还是实现Runnable接口来实现多线程，最终还是通过Thread的对象的API来控制线程的，熟悉Thread类的API是进行多线程编程的基础。

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

1.3 使用匿名内部类方式

使用线程的内匿名内部类方式，可以方便的实现每个线程执行不同的线程任务操作。
使用匿名内部类的方式实现Runnable接口，重新Runnable接口中的run方法：

  • 代码如下：

    /**
* @author bruceliu
* @create 2019-05-30 11:55
* @description 使用匿名内部类方式
*/
public class NoNameInnerClassThread {

public static void main(String[] args) {
    System.out.println("-----多线程创建开始-----");
    //‐‐‐这个整体 相当于new MyRunnable()
    Runnable r = new Runnable(){
        public void run(){
            for (int i = 0; i < 20; i++) {
                System.out.println("张宇:"+i);
            }
        }
    };
    new Thread(r).start();
    for (int i = 0; i < 20; i++) {
        System.out.println("费玉清:"+i);
    }
    System.out.println("-----多线程创建结束-----");
}
}
    1.4.Thread和Runnable的区别

    如果一个类继承Thread，则不适合资源共享。但是如果实现了Runable接口的话，则很容易的实现资源共享。
    总结：

  • 实现Runnable接口比继承Thread类所具有的优势：
    1. 适合多个相同的程序代码的线程去共享同一个资源。
    2. 可以避免java中的单继承的局限性。
    3. 增加程序的健壮性，实现解耦操作，代码可以被多个线程共享，代码和线程独立。
    4. 线程池只能放入实现Runable或Callable类线程，不能直接放入继承Thread的类。

在java中，每次程序运行至少启动2个线程。一个是main线程，一个是垃圾收集线程。因为每当使用
java命令执行一个类的时候，实际上都会启动一个JVM，每一个JVM其实在就是在操作系统中启动了一个进程。

2.Thread类

我们已经可以完成最基本的线程开启，那么在我们完成操作过程中用到了 java.lang.Thread 类，
API中该类中定义了有关线程的一些方法，具体如下：

  • 构造方法：
    public Thread() :分配一个新的线程对象。
    public Thread(String name) :分配一个指定名字的新的线程对象。
    public Thread(Runnable target) :分配一个带有指定目标新的线程对象。
    public Thread(Runnable target,String name) :分配一个带有指定目标新的线程对象并指定名字。
  • 常用方法方法：
    public String getName() :获取当前线程名称。
    public void start() :导致此线程开始执行; Java虚拟机调用此线程的run方法。
    public void run() :此线程要执行的任务在此处定义代码。
    public static void sleep(long millis) :使当前正在执行的线程以指定的毫秒数暂停（暂时停止执行）。
    public static Thread currentThread() :返回对当前正在执行的线程对象的引用

    3.守护线程

    在Java中有两类线程：User Thread(用户线程)、Daemon Thread(守护线程)
    用个比较通俗的比如，任何一个守护线程都是整个JVM中所有非守护线程的保姆：只要当前JVM实例中尚存在任何一个非守护线程没有结束，守护线程就全部工作；只有当最后一个非守护线程结束时，守护线程随着JVM一同结束工作。Daemon的作用是为其他线程的运行提供便利服务，守护线程最典型的应用就是 GC (垃圾回收器)，它就是一个很称职的守护者。
    User和Daemon两者几乎没有区别，唯一的不同之处就在于虚拟机的离开：如果 User Thread已经全部退出运行了，只剩下Daemon Thread存在了，虚拟机也就退出了。 因为没有了被守护者，Daemon也就没有工作可做了，也就没有继续运行程序的必要了。

首先看下哪些是守护线程，哪些是非守护线程

值得一提的是，守护线程并非只有虚拟机内部提供，用户在编写程序时也可以自己设置守护线程。下面的方法就是用来设置守护线程的。

Thread daemonTread = new Thread();  

  // 设定 daemonThread 为 守护线程，default false(非守护线程)
 daemonThread.setDaemon(true);  

 // 验证当前线程是否为守护线程，返回 true 则为守护线程
 daemonThread.isDaemon();

代码示例：

/**
 * @author bruceliu
 * @create 2019-06-01 17:46
 * @description 守护线程:进程线程(主线程挂了) 守护线程也会被自动销毁.
 */
public class DaemonThread {

    public static void main(String[] args) {

        System.out.println("----------->主线程执行开始......");

        Thread thread=new Thread(new Runnable() {
            @Override
            public void run() {
                while(true){
                    try {
                        Thread.sleep(1000);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    } finally {
                    }
                    System.out.println("我是子线程......");
                }
            }
        });

        //设置为守护线程
        thread.setDaemon(true);
        thread.start();

        for (int i = 0; i <10 ; i++) {
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            } finally {
            }
            System.out.println("我是主线程...");
        }
        System.out.println("----------->主线程执行完毕......");

    }
}

原文地址：https://blog.51cto.com/13819911/2406077

时间： 2024-11-06 09:50:36

并发编程专题(二)-线程的创建方式的相关文章

Java并发编程(01)：线程的创建方式，状态周期管理

本文源码:GitHub·点这里 || GitEE·点这里 一.并发编程简介 1.基础概念 程序 与计算机系统操作有关的计算机程序.规程.规则,以及可能有的文件.文档及数据. 进程 进程是计算机中的程序,关于某数据集合上的一次运行活动,是系统进行资源分配和调度的基本单位,是操作系统结构的基础.在早期面向进程设计的计算机结构中,进程是程序的基本执行实体:在面向线程设计的计算机结构中,进程是线程的容器.程序是指令.数据及其组织形式的描述,进程是程序的实体. 线程 线程是操作系统能够进行运算调度的最小单

并发编程专题(三)-线程的状态

1.线程状态 Java中,线程的状态使用一个枚举类型来描述的.这个枚举一共有6个值: NEW(新建).RUNNABLE(运行).BLOCKED(锁池).TIMED_WAITING(定时等待).WAITING(等待).TERMINATED(终止.结束).但是大多数人的理解和上面的这六种还是有些差别,通常会加上阻塞状态,可运行状态,挂起状态.在API中 java.lang.Thread.State 这个枚举中给出了六种线程状态,这是Thread类描述线程状态的枚举类的源代码: public enum

JAVA 并发编程之守护线程的创建与运行

java里有一种特殊的线程叫做守护线程(Daemon)线程.这种线程的优先级很低,通常来说,当同一个应用程序里没有其他的线程运行的时候,守护线程才运行.当程序中唯一运行的的线程是守护线程时,并且守护线程执行结束后 ,JVM也就结束了这个程序. 因为这种特性,守护线程通常被用来作为同一程序中普通线程(用户线程)的服务提供者.它们通常是无线循环的,以等待服务请求或者执行线程的任务.它们不能做重要工作,因为我们不可能知道守护线程什么时候获取CPU时钟,并且,在没有其他线程运行时,守护线程随时可以结束.

关于线程的创建方式，线程池的作用

线程的创建方式: 1.线程继承Thread类,通过该对象的start()方法启动线程 2.线程实现Runnable接口,通过往Thread类构造传入Runnable对象,thread.start()启动线程. 3.线程实现Callable接口.Callable相当于run方法有返回值的Runnable,与Future结合使用(接收返回值使用Future). 线程池的使用,为什么使用线程池? 复用线程,使用工作队列,避免无限制创建线程.重用线程降低开销,请求到达时,线程已存在,减少创建线程的等待时

线程的创建方式

引入案例: (售卖100张电影票) 1.继承Thread 类 2.实现Runnable 接口   3.实现Callable 接口 扩展: 4.使用匿名内部类 创建线程 5.使用lambda表达式 创建线程 线程的创建方式 原文地址:https://www.cnblogs.com/penguin1024/p/11762141.html

Java并发编程（二）-- 创建、运行线程

Java线程 Java线程类也是一个object类,它的实例都继承自java.lang.Thread或其子类. Java可以用如下方式创建一个线程: Tread thread = new Thread(); 执行该线程可以调用该线程的start()方法: thread.start(); 在上面的例子中,我们并没有为线程编写运行代码,因此调用该方法后线程就终止了. 创建.执行线程的方式 无返回: 实现Runnable接口; 继承Thread类,重写run(); 有返回: 实现Callable接口,

[笔记][Java7并发编程实战手册]4.3 创建固定的线程执行器newFixedThreadPool线程池

[笔记][Java7并发编程实战手册]系列目录 简介 newFixedThreadPool(int nThreads, ThreadFactory threadFactory) 创建一个可重用固定线程数的线程池,以共享的无界队列方式来运行这些线程,在需要时使用提供的 ThreadFactory 创建新线程. newCachedThreadPool()创建的线程池的特性是:自动回收不使用的线程(终止并从缓存中移除那些已有 60 秒钟未被使用的线程),(在无可用线程的情况下)自动的为新来的task创

Java并发编程(02)：线程核心机制，基础概念扩展

本文源码:GitHub·点这里 || GitEE·点这里 一.线程基本机制 1.概念描述 并发编程的特点是:可以将程序划分为多个分离且独立运行的任务,通过线程来驱动这些独立的任务执行,从而提升整体的效率.下面提供一个基础的演示案例. 2.应用案例 场景:假设有一个容器集合,需要拿出容器中的每个元素,进行加工处理,一般情况下直接遍历就好,如果数据偏大,可以根据线程数量对集合切割,每个线程处理一部分数据,这样处理时间就会减少很多. public class ExtendThread01 { publ

并发编程总结——java线程基础1

最近没事,顺便看看java并发编程的东西,然后总结纪录下来,大家如果能看到帮忙指正指正哈哈,另外一方面也为以后自己回顾的时候可以看看. 关于并发编程,准备从几个点切入: 1.java线程几本知识 2.juc原子类 3.锁 4.juc集合 5.线程池 ------------------------------------------------------------------- 分割线开始.... 说到多线程,java中超父类Object中有wait()和notify()方法,包括Runna