1.线程与Thread类

1.1操作系统中的线程与Java线程

1.1.1线程与Thread类

线程是操作系统中的概念. 操作系统内核实现了线程这样的机制, 并且对用户层提供了一些 API 供用户使用(例如 Linux 的 pthread 库).
Java 标准库中 Thread 类可以视为是对操作系统提供的 API 进行了进一步的抽象和封装. 也就是说Thread类的一个实例就对应着一个线程。

1.1.2Thread类的构造方法

序号 方法名 解释
1 public Thread() 无参数构造方法
2 public Thread(Runnable target) 传入实现Runnable接口的对象(任务对象)构造线程
3 public Thread(Runnable target, String name) 根据目标任务并指定线程名创建线程
4 public Thread(ThreadGroup group, Runnable target) 根据线程组和任务创建线程(了解)
5 public Thread(ThreadGroup group, Runnable target, String name) 比构造方法4多一个指定线程名
6 public Thread(String name) 指定线程名创建线程
7 public Thread(ThreadGroup group, String name) 根据线程组并指定线程名创建线程
8 public Thread(ThreadGroup group, Runnable target, String name,long stackSize) 构造函数与构造方法5相同,只是它允许指定线程堆栈大小

 注:线程可以被用来分组管理,分好的组即为线程组,Runnable类表示任务类,也就是线程需执行的任务。

1.1.3启用java线程必会的方法

想要使用java线程至少得知道Thread类中这几个方法:

方法名 解释
public void run() 该方法用来封装线程运行时执行的内容
public synchronized void start() 线程创建并执行run方法
public static native void sleep(long millis) throws InterruptedException 使线程休眠millis毫秒

创建Thread对象,必须重写run方法,因为你创建一个线程肯定要用运行一些代码嘛。

1.2第一个Java多线程程序

首先,我们可以创建一个MyThread类继承Thread类,并重写run方法。

class MyThread extends Thread{
    //重写run方法
    @Override
    public void run() {
        System.out.println("你好!线程!");
    }
}
public class TestDemo {
    public static void main(String[] args) {
        //创建MyThread线程对象,但是线程没有创建
        Thread thread = new MyThread();
        //线程创建并运行
        thread.start();
    }
}

使用new创建线程对象,线程并没有被创建,仅仅只是单纯地创建了一个线程对象,运行start方法时才会创建线程并执行run方法。

运行结果:

1.3使用Runnable对象创建线程

除了使用子类继承Thread类并重写run方法,使用子类实现Runnable接口(该接口中也有一个run方法,表示任务的内容),该对象可以理解为“任务”,也就是说Thread对象可以接受Runnable引用,并执行Runnable引用的run方法。

因为Runable是一个接口,所以需要实现run方法,线程Thread对象创建好后,此时线程并没有创建运行,需要调用start方法来创建启动线程。

class MyRunnable implements Runnable {
    @Override
    public void run() {
        System.out.println("使用Runnable描述任务!");
    }
}

public class TestDemo3 {
    public static void main(String[] args) {
        //将Runnable任务传给Thread对象来创建运行线程
        Runnable runnable = new MyRunnable();
        Thread thread = new Thread(runnable);

        thread.start();
    }
}

运行结果:

根据“低内聚,高耦合”的

编程风格,使用Runnable的方式创建更优。

1.4使用内部类创建线程

当然也可以使用匿名内部类,来传入匿名对象来重写run方法。

public class TestDemo4 {
    public static void main(String[] args) {
        Thread thread = new Thread() {
            @Override
            public void run() {
                System.out.println("使用匿名内部类创建线程匿名对象");
            }
        };
        thread.start();
    }
}

运行结果:

1.5使用Lambda表达式创建线程

使用Lambda表达式,本质还是使用匿名内部类创建的Thread

public class TestDemo6 {
    public static void main(String[] args) {
        Thread thread = new Thread(() -> System.out.println("使用Lambda表达式表示匿名内部类来创建匿名任务"));
        thread.start();
    }
}

运行结果:

1.6多线程并发执行简单演示

在一个进程中至少会有一个线程,如果不使用多线程编程,一个进程中默认会有执行main方法的main线程(该线程是自动创建的),当你创建一个新的线程t,该线程会与main线程并发执行。

public class TestDemo7 {
    public static void main(String[] args) {
        //thread 线程
        Thread thread = new Thread(new Runnable() {
            @Override
            public void run() {
                for (int i = 0; i < 10; i  ) {
                    System.out.println("thread线程执行中!");
                    //为了使效果更加明显 可以使用sleep方法设定线程睡眠时间
                    try {
                        Thread.sleep(1000);//每执行一次循环就睡眠1秒
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }
            }
        });
        thread.start();

        //main 线程
        for (int i = 0; i < 10; i  ) {
            System.out.println("main线程执行中!");
            //为了使效果更加明显 可以使用sleep方法设定线程睡眠时间
            try {
                Thread.sleep(1000);//每执行一次循环就睡眠1秒
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }
}

运行结果:

从上面的运行结果可以看出一个问题,因为thread线程与main线程都是每打印一句语句线程休眠1秒,两个线程唤醒的先后顺序是随机的,这也是java多线程中的一个“万恶之源”,这个问题给我们带来了很多麻烦,细节等后续的博客细说。

1.7多线程并发执行的优势

加入我们现在有一个任务,就是分别将ab两个变量都自增20亿次,我们来看看使用两个线程和单独使用一个线程分别所需的时间是多少。

public class Test {
    private static final long COUNT = 20_0000_0000L;
    //两个线程
    public static void many() throws InterruptedException {
        //获取开始执行时间戳
        long start = System.currentTimeMillis();

        Thread thread1 = new Thread(() -> {
            long a = 0;
            for (long i = 0; i < COUNT; i  ) {
                a  ;
            }
        });
        thread1.start();
        Thread thread2 = new Thread(() -> {
            long b = 0;
            for (long i = 0; i < COUNT; i  ) {
                b  ;
            }
        });
        thread2.start();

        //等待两个线程结束 再获取结束时的时间戳
        thread1.join();
        thread2.join();
        long end = System.currentTimeMillis();

        //执行时间,单位为毫秒
        System.out.println("多线程执行时间:"   (end - start)   "ms");
    }
    //单线程
    public static void single() {
        //记录开始执行的时间戳
        long start = System.currentTimeMillis();

        long a = 0;
        for (long i = 0; i < COUNT; i  ) {
            a  ;
        }
        long b = 0;
        for (long i = 0; i < COUNT; i  ) {
            b  ;
        }
        //获取执行结束时的时间戳
        long end = System.currentTimeMillis();
        System.out.println("单线程执行时间:"   (end - start)   "ms");
    }

    public static void main(String[] args) throws InterruptedException {
        //多线程
        many();
        //单线程
        single();
    }
}

我们来看看完成这个任务所需的时间:

根据结果我们发现两个线程并发执行的时间大约是500ms左右,单线程执行的时间大约是1000ms左右,当然如果任务量不够大,可能多线程相比于单线程并不会有优势,毕竟创建线程本身还是有开销的。

2.Thread类的常用属性与方法

2.1Thread类中的重要属性

属性 获取该属性的方法
线程的唯一标识ID public long getId()
线程的名称name public final String getName()
线程的状态state public State getState()
线程的优先级priority public final int getPriority()
线程是否后台线程 public final boolean isDaemon()
线程是否存活 public final native boolean isAlive()
线程是否中断 public boolean isInterrupted()

每一个线程都拥有一个id作为标识,其中处于同一进程的所有线程id相同,每个进程间都有唯一的id标识。
线程也是拥有名字的,如果我们创建Thread对象时,没有指定线程对象的名称,则会默认命名为Thread-i,其中i为整数。

通过了解进程,我们知道进程拥有3种状态,分别为阻塞,执行和就绪。而java中的线程也有类似与这种状态的定义,后面我们细说,优先级也一样就不用多说了。

java线程分为后台线程与前台线程,其中后台线程不会影响到进程的退出,而前台线程会影响进程的退出,比如有线程t1与线程t2,当这两个线程为前台线程时,main方法执行完毕时,t1t2不会立即退出,要等到线程执行完毕,整个进程才会退出,反之,当这两个线程为后台线程时,main方法执行完毕时,t1t2线程被强制结束,整个进程也就结束了。

关于java线程的属性,我们可以通过java官方的jconsole调试工具查看java线程的一些属性。 这个工具一般在jdk的bin目录,

双击打开有如下界面:

选择需要查看的线程并查看:

选择你需要查看的进程属性:

2.2Thread类中常用方法总结

2.2.1常用方法

方法名 解释
public void run() 该方法用来封装线程运行时执行的内容
public synchronized void start() 线程创建并执行run方法
public static native void sleep(long millis) throws InterruptedException 使线程休眠millis毫秒
public final void join() throws InterruptedException 等待线程结束(在哪个线程中调用哪个对象的join方法,哪个线程就等待哪个对象)
public final synchronized void join(long millis) throws InterruptedException 等待线程结束,最多等待millis毫秒
public final synchronized void join(long millis, int nanos) throws InterruptedException 指定最多等待时间等待线程,精确到纳秒
public void interrupt() 中断线程对象所关联的对象,如果线程在休眠(阻塞状态)会抛出异常通知,否则设置中断标志位
public static boolean interrupted() 判断当前线程的中断标志位是否设置,调用后会清除线程的中断标志位
public boolean isInterrupted() 判断当前线程的中断标志位是否设置,调用后不会影响线程的标志位
public final synchronized void setName(String name) 修改线程对象名称
public static native Thread currentThread() 获取当前线程对象

2.2.2中断线程

如果我们想中断一个正在执行的线程,该如何做呢?最简单但不严谨的方法就是我们在run方法中定义一个中断标志位(需要中断时标志位为true,默认情况为false),每次执行具体任务时需要先判断中断标志位是否为true,如果是就结束线程,否则继续执行。

public class TestDemo8 {
    private static boolean isQuit = false;
    public static void main(String[] args) throws InterruptedException {
        Thread thread = new Thread(() -> {
            while(!isQuit) {
                //每隔1秒打印一句
                System.out.println("一个不起眼的线程!");
                try {
                    Thread.sleep(1000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        });
        thread.start();
        //main线程阻塞5秒 按理会打印5句话
        Thread.sleep(5000);
        isQuit = true;
    }
}

运行结果:

但是该方法是不够严谨的,有些场景可能达不到预期的效果,最优的做法就是调整线程对象或者线程类中的自带标志位。

方式1:使用Thread对象中的标志位首先使用 currentThread方法获取线程对象,然后再调用该对象中的isterrupted方法获取该对象的中断标志位代替我们自己所写的isQuit标志位,然后等该线程运行一段时间后使用interrupt方法改变标志位,中断线程,写出如下代码,看看能不能达到预期效果:

public class TestDemo9 {
    public static void main(String[] args) throws InterruptedException {
        Thread thread = new Thread(() ->{
            while (!Thread.currentThread().isInterrupted()) {
                System.out.println("又是一个不起眼的线程!");
                try {
                    Thread.sleep(1000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        });
        thread.start();

        //main休眠5秒
        Thread.sleep(5000);

        //使用interrupt方法修改线程标志位,使其中断
        thread.interrupt();
    }
}

我们来看一看:

失败了,抛出一个InterruptedException异常后,线程没有中断,而是继续运行,原因是interrupt方法遇到因为调用 wait/join/sleep 等方法而阻塞的线程时会使sleep等方法抛出异常,并且中断标志位不会修改为true,这时我们的catch语句里面值输出了异常信息并没有去中断异常,所以我们需要在catch语句中加上线程结束的收尾工作代码和退出任务循环的break语句就可以了。

public class TestDemo9 {
    public static void main(String[] args) throws InterruptedException {
        Thread thread = new Thread(() ->{
            while (!Thread.currentThread().isInterrupted()) {
                System.out.println("又是一个不起眼的线程!");
                try {
                    Thread.sleep(1000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                    //收尾工作
                    System.out.println("收尾工作!");
                    break;
                }
            }
        });
        thread.start();

        //main休眠5秒
        Thread.sleep(5000);

        //使用interrupt方法修改线程标志位,使其中断
        thread.interrupt();
    }
}

运行结果:

方式2:使用Thread类中的标志位除了isInterrupted,还有一个静态方法interrupted能够访问类中的标志位,一般一个程序中只有一个,我们也可以使用该静态方法来作为中断标志位,然后到时机后使用interrupt方法来中断线程执行。

public class TestDemo10 {
    public static void main(String[] args) throws InterruptedException {
        Thread thread = new Thread(() -> {
            while (!Thread.interrupted()) {
                System.out.println("又又是一个不起眼的线程!");
                try {
                	//设置打印频率为1s
                    Thread.sleep(1000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                    //收尾工作
                    System.out.println("收尾工作!");
                    break;
                }
            }
        });
        thread.start();

        //main休眠5秒
        Thread.sleep(5000);

        //使用interrupt方法修改线程标志位,使其中断
        thread.interrupt();
    }
}

运行结果:

综上所述,一般以方式1的方式无脑中断线程就可以。

2.2.3线程等待

像上面的计算自增20亿次的例子就需要线程等待join方法,main线程需要等两个线程运行完毕后才能计算计算结束时的时间戳。
针对这一点java还准备了带参数的join方法,可以指定最长的等待时间。
还有一个细节那join方法是谁等谁呢?
我们来假设几个线程,线程A表示调用join方法的线程,线程B表示join方法来自B线程对象,那么在A线程使用B.join方法,那就是A线程等待B线程结束。

2.2.4start方法与run方法的区别

我们知道执行一个线程的任务就是线程对象中所重写的run方法,那么可以直接调用run方法来代替start方法吗?

当然不行!因为你调用run方法就是单纯地调用了Thread对象中的一个普通方法而已,并没有创建一个新线程来执行run方法,而是通过main线程来执行的run方法,而使用start方法,会创建一个新线程并执行run方法。

3.Java线程的状态

3.1java线程中的基本状态

操作系统中进程的状态有三种分别为阻塞,就绪和执行,而java线程中的状态基本上相同,但做了细分,有一点区别,我们来认识一下。

NEW: 安排了工作, 还未开始行动,就是线程对象存在,但没有执行start方法,java内部的状态,与进程中的状态无关。
RUNNABLE: 就绪状态。
BLOCKED: 线程正在等待锁释放而引起的阻塞状态(synchronized加锁)。
WAITING: 线程正在等待等待唤醒而引起的阻塞状态(waitf方法使线程等待唤醒)。
TIMED_WAITING: 在一段时间内处于阻塞状态,通常是使用sleep或者join(带参数)方法引起。
TERMINATED:Thread对象还存在,但是关联的线程已经工作完成了,java内部的状态,与进程中的状态无关。

3.2线程状态转移

我先使用一个流程图来简要说明状态之间的关系:

上面这个图简单地说明了这几种状态之间的转移,关于图中的wait以及synchronized关键字会在讨论线程安全问题时介绍。

这期的内容分享了有关线程创建执行以及有关Thread类中的基本方法,下期继续介绍多线程更深入的知识,比如线程安全问题,如何加锁等更深一点的内容。

到此这篇关于Java线程创建与Thread类的使用方法的文章就介绍到这了,更多相关Java线程内容请搜索Devmax以前的文章或继续浏览下面的相关文章希望大家以后多多支持Devmax!

Java线程创建与Thread类的使用方法的更多相关文章

  1. iOS:核心图像和多线程应用程序

    我试图以最有效的方式运行一些核心图像过滤器.试图避免内存警告和崩溃,这是我在渲染大图像时得到的.我正在看Apple的核心图像编程指南.关于多线程,它说:“每个线程必须创建自己的CIFilter对象.否则,你的应用程序可能会出现意外行为.”这是什么意思?我实际上是试图在后台线程上运行我的过滤器,所以我可以在主线程上运行HUD(见下文).这在coreImage的上下文中是否有意义?

  2. ios – 多个NSPersistentStoreCoordinator实例可以连接到同一个底层SQLite持久性存储吗?

    我读过的关于在多个线程上使用CoreData的所有内容都讨论了使用共享单个NSPersistentStoreCoordinator的多个NSManagedobjectContext实例.这是理解的,我已经使它在一个应用程序中工作,该应用程序在主线程上使用CoreData来支持UI,并且具有可能需要一段时间才能运行的后台获取操作.问题是NSPersistentStoreCoordinator会对基础

  3. ios – XCode断点应该只挂起当前线程

    我需要调试多线程错误.因此,为了获得生成崩溃的条件,我需要在代码中的特定点停止一个线程,并等待另一个线程到达第二个断点.我现在遇到的问题是,如果一个线程遇到断点,则所有其他线程都被挂起.有没有办法只停止一个线程,让其他线程运行,直到它们到达第二个断点?)其他更有趣的选择:当你点击第一个断点时,你可以进入控制台并写入这应该在该断点处暂停当前上下文中的线程一小时.然后在Xcode中恢复执行.

  4. ios – 在后台线程中写入Realm后,主线程看不到更新的数据

    >清除数据库.>进行API调用以获取新数据.>将从API检索到的数据写入后台线程中的数据库中.>从主线程上的数据库中读取数据并渲染UI.在步骤4中,数据应该是最新数据,但我们没有看到任何数据.解决方法具有runloops的线程上的Realm实例,例如主线程,updatetothelatestversionofthedataintheRealmfile,因为通知被发布到其线程的runloop.在后台

  5. ios – NSURLConnectionLoader线程中的奇怪崩溃

    我们开始看到我们的应用启动时发生的崩溃.我无法重现它,它只发生在少数用户身上.例外情况是:异常类型:EXC_BAD_ACCESS代码:KERN_INVALID_ADDRESS位于0x3250974659崩溃发生在名为com.apple.NSURLConnectionLoader的线程中在调用时–[NSBlockOperationmain]这是该线程的堆栈跟踪:非常感谢任何帮助,以了解可能导致这种崩

  6. ios – 合并子上下文时的NSObjectInaccessbileExceptions

    我尝试手动重现,但失败了.是否有其他可能发生这种情况的情况,是否有处理此类问题的提示?解决方法在创建子上下文时,您可以尝试使用以下行:

  7. ios – 从后台线程调用UIKit时发出警告

    你如何处理项目中的这个问题?

  8. ios – 在SpriteKit中,touchesBegan在与SKScene更新方法相同的线程中运行吗?

    在这里的Apple文档AdvancedSceneProcessing中,它描述了更新方法以及场景的呈现方式,但没有提到何时处理输入.目前尚不清楚它是否与渲染循环位于同一个线程中,或者它是否与它并发.如果我有一个对象,我从SKScene更新方法和touchesBegan方法(在这种情况下是SKSpriteNode)更新,我是否要担心同步对我的对象的两次访问?解决方法所以几天后没有回答我设置了一些实验

  9. ios – 在后台获取中加载UIWebView

    )那么,有一种方法可以在后台加载UIWebView吗?解决方法如果要从用户界面更新元素,则必须在应用程序的主队列(或线程)中访问它们.我建议您在后台继续获取所需的数据,但是当需要更新UIWebView时,请在主线程中进行.你可以这样做:或者您可以创建一个方法来更新UIWebView上的数据,并使用以下方法从后台线程调用它:这将确保您从正确的线程访问UIWebView.希望这可以帮助.

  10. ios – 何时使用Semaphore而不是Dispatch Group?

    我会假设我知道如何使用DispatchGroup,为了解问题,我尝试过:结果–预期–是:为了使用信号量,我实现了:并在viewDidLoad方法中调用它.结果是:从概念上讲,dispachGroup和Semaphore都有同样的目的.老实说,我不熟悉:什么时候使用信号量,尤其是在与dispachGroup合作时–可能–处理问题.我错过了什么部分?

随机推荐

  1. 基于EJB技术的商务预订系统的开发

    用EJB结构开发的应用程序是可伸缩的、事务型的、多用户安全的。总的来说,EJB是一个组件事务监控的标准服务器端的组件模型。基于EJB技术的系统结构模型EJB结构是一个服务端组件结构,是一个层次性结构,其结构模型如图1所示。图2:商务预订系统的构架EntityBean是为了现实世界的对象建造的模型,这些对象通常是数据库的一些持久记录。

  2. Java利用POI实现导入导出Excel表格

    这篇文章主要为大家详细介绍了Java利用POI实现导入导出Excel表格,文中示例代码介绍的非常详细,具有一定的参考价值,感兴趣的小伙伴们可以参考一下

  3. Mybatis分页插件PageHelper手写实现示例

    这篇文章主要为大家介绍了Mybatis分页插件PageHelper手写实现示例,有需要的朋友可以借鉴参考下,希望能够有所帮助,祝大家多多进步,早日升职加薪

  4. (jsp/html)网页上嵌入播放器(常用播放器代码整理)

    网页上嵌入播放器,只要在HTML上添加以上代码就OK了,下面整理了一些常用的播放器代码,总有一款适合你,感兴趣的朋友可以参考下哈,希望对你有所帮助

  5. Java 阻塞队列BlockingQueue详解

    本文详细介绍了BlockingQueue家庭中的所有成员,包括他们各自的功能以及常见使用场景,通过实例代码介绍了Java 阻塞队列BlockingQueue的相关知识,需要的朋友可以参考下

  6. Java异常Exception详细讲解

    异常就是不正常,比如当我们身体出现了异常我们会根据身体情况选择喝开水、吃药、看病、等 异常处理方法。 java异常处理机制是我们java语言使用异常处理机制为程序提供了错误处理的能力,程序出现的错误,程序可以安全的退出,以保证程序正常的运行等

  7. Java Bean 作用域及它的几种类型介绍

    这篇文章主要介绍了Java Bean作用域及它的几种类型介绍,Spring框架作为一个管理Bean的IoC容器,那么Bean自然是Spring中的重要资源了,那Bean的作用域又是什么,接下来我们一起进入文章详细学习吧

  8. 面试突击之跨域问题的解决方案详解

    跨域问题本质是浏览器的一种保护机制,它的初衷是为了保证用户的安全,防止恶意网站窃取数据。那怎么解决这个问题呢?接下来我们一起来看

  9. Mybatis-Plus接口BaseMapper与Services使用详解

    这篇文章主要为大家介绍了Mybatis-Plus接口BaseMapper与Services使用详解,有需要的朋友可以借鉴参考下,希望能够有所帮助,祝大家多多进步,早日升职加薪

  10. mybatis-plus雪花算法增强idworker的实现

    今天聊聊在mybatis-plus中引入分布式ID生成框架idworker,进一步增强实现生成分布式唯一ID,具有一定的参考价值,感兴趣的小伙伴们可以参考一下

返回
顶部