java多线程

简介: Java多线程 部分转载自知乎用户 Snailclimb · 南理汉子 · 很好 Table of contents进程和多线程简介使用多线程实例变量和线程安全一些常用方法如何停止一个线程线程的优先级Java多线程分类简介相关概念多线程概念何为线程何为进程线程和进程有何不同通俗说法开个QQ,开了一个进程;开了迅雷,开了一个进程。

Java多线程

部分转载自知乎用户 Snailclimb · 南理汉子 · 很好

Table of contents

简介

概念

通俗说法
开个QQ,开了一个进程;开了迅雷,开了一个进程。在QQ的这个进程里,传输文字开一个线程、传输语音开了一个线程、弹出对话框又开了一个线程。所以运行某个软件,相当于开了一个进程。在这个软件运行的过程里(在这个进程里),多个工作支撑的完成QQ的运行,那么这“多个工作”分别有一个线程。所以一个进程管着多个线程。通俗的讲:“进程是爹妈,管着众多的线程儿子”...

线程

线程进程的一个实体,是CPU调度和分派的基本单位,他是比进程更小的能独立运行的基本单位,线程自己基本上不拥有系统资源。

进程

是具有一定独立功能的程序、它是系统进行资源分配和调度的一个独立单位,重点在系统调度和单独的单位,也就是说进程是可以独 立运行的一段程序。

线程和进程有何不同

关系:

  1. 一个线程只能属于一个进程,而一个进程可以有多个线程,但至少有一个线程(通常说的主线程)
  2. 资源分配给进程,同一进程的所有线程共享该进程的所有资源
  3. 线程在执行过程中,需要协作同步。不同进程的线程间要利用消息通信的办法实现同步。
  4. 处理机分给线程,即真正在处理机上运行的是线程
  5. 线程是指进程内的一个执行单元,也是进程内的可调度实体

区别:

  1. 调度:线程作为调度和分配的基本单位,进程作为拥有资源的基本单位。
  2. 并发性:不仅进程之间可以并发执行,同一个进程的多个线程之间也可以并发执行。
  3. 拥有资源:进程是拥有资源的一个独立单位,线程不拥有系统资源,但可以访问隶属于进程的资源。

多线程

多线程

多线程就是几乎同时执行多个线程(一个处理器在某一个时间点上永远都只能是一个线程!即使这个处理器是多核的,除非有多个处理器才能实现多个线程同时运行。)。几乎同时是因为实际上多线程程序中的多个线程实际上是一个线程执行一会然后其他的线程再执行,并不是很多书籍所谓的同时执行。

为什么多线程是必要的

  1. 使用线程可以把占据长时间的程序中的任务放到后台去处理
  2. 用户界面可以更加吸引人,这样比如用户点击了一个按钮去触发某些事件的处理,可以弹出一个进度条来显示处理的进度
  3. 程序的运行速度可能加快

假设你的公司从上到下都不知道多线程有什么用,就你知道。你刚进公司。比如你的机器是intel i7 4核,你要跑一个运算4万次,每次都独立,不考虑IO负担。那么,单线程你只能用到一个核,耗时40分钟,你打开任务管理器,看到CPU利用率一直是25%。你修改程序,开4个线程,每个算1万次,你看到CPU利用率一直是100%,耗时10分钟。你告诉老板40分钟后完成任务,10分钟后你检查完毕起身去买了杯咖啡,回来开始刷知乎。30分钟过后刷过瘾了,你发信息告诉老板任务完成。老板说:Good job.

使用

继承Thread类

MyThread.java

public class MyThread extends Thread {
    @Override
    public void run() {
        super.run();
        int i = 1000;
        while (--i > 0) {

        System.out.println("|||||||||||||||||");
        }
        System.out.println("MyThread");
    }
}

Run.java

public class Run {
    public static void main(String[] args) {
        MyThread mythread = new MyThread();
        mythread.start();
        System.out.println("运行结束");
    }
}

运行结果:

运行结束
|||||||||||||||||
...
...
|||||||||||||||||
MyThread

以共有两个线程,一个是main,一个是mythread,如果把他们两个比作赛跑选手,main选手要做的事情是,先开始跑,紧接着喊mythread一声,老哥,开始跑吧,然后再喊一声运行结束,他就完成了任务,而mythread需要执行完一个长循环才可以结束

实现Runnable接口

推荐实现Runnable接口方式开发多线程,因为Java单继承但是可以实现多个接口,也就是相比上一个方法,这个方法在实现了多线程的同时还多出了选择继承一个父类的权利

MyRunnable.java

public class MyRunnable implements Runnable {
    @Override
    public void run() {
        System.out.println("MyRunnable");
    }
}

Run.java

public class Run {

    public static void main(String[] args) {
        Runnable runnable=new MyRunnable();
        Thread thread=new Thread(runnable);
        thread.start();
        System.out.println("运行结束!");
    }

}

运行结果
运行结束!
MyRunnable

实例变量和线程安全

定义线程类中的实例变量针对其他线程可以有共享和不共享之分

不共享数据的情况

MyThread.java

public class MyThread extends Thread {

    private int count = 5;

    public MyThread(String name) {
        super();
        this.setName(name);
    }

    @Override
    public void run() {
        super.run();
        while (count > 0) {
            count--;
            System.out.println("由 " + MyThread.currentThread().getName()
                    + " 计算,count=" + count);
        }
    }
}

Run.java

public class Run {
    public static void main(String[] args) {
        MyThread a = new MyThread("A");
        MyThread b = new MyThread("B");
        MyThread c = new MyThread("C");
        a.start();
        b.start();
        c.start();
    }
}

运行结果
由 A 计算,count=4
由 B 计算,count=4
由 C 计算,count=4
由 B 计算,count=3
由 A 计算,count=3
由 A 计算,count=2
由 A 计算,count=1
由 A 计算,count=0
由 B 计算,count=2
由 C 计算,count=3
由 B 计算,count=1
由 C 计算,count=2
由 B 计算,count=0
由 C 计算,count=1
由 C 计算,count=0

可以看出每个线程都有一个属于自己的实例变量count,它们之间互不影响。我们再来看看另一种情况。

共享数据的情况

MyThread.java

public class MyThread extends Thread {

    private int count = 5;

    @Override
     public void run() {
        super.run();
        count--;
        System.out.println("由 " + MyThread.currentThread().getName() + " 计算,count=" + count);
    }
}

Run.java

public class Run {
    public static void main(String[] args) {

        MyThread mythread=new MyThread();
        //下列线程都是通过mythread对象创建的
        Thread a=new Thread(mythread,"A");
        Thread b=new Thread(mythread,"B");
        Thread c=new Thread(mythread,"C");
        Thread d=new Thread(mythread,"D");
        Thread e=new Thread(mythread,"E");
        a.start();
        b.start();
        c.start();
        d.start();
        e.start();
    }
}

运行结果
由 A 计算,count=3
由 C 计算,count=2
由 B 计算,count=3
由 D 计算,count=1
由 E 计算,count=0
可以看出这里已经出现了错误,我们想要的是依次递减的结果。为什么呢??

因为在大多数jvm中,count--的操作分为如下下三步:

  1. 取得原有count值
  2. 计算i -1
  3. 对i进行赋值

所以多个线程同时访问时出现问题就是难以避免的了。

那么有没有什么解决办法呢?

答案是:当然有,而且很简单。

在run方法前加上synchronized关键字即可得到正确答案。

加上关键字后的运行结果:

由 A 计算,count=4
由 E 计算,count=3
由 D 计算,count=2
由 B 计算,count=1
由 C 计算,count=0

一些常用方法

currentThread()

返回对当前正在执行的线程对象的引用。

getId()

返回此线程的标识符

getName()

返回此线程的名称

getPriority()

返回此线程的优先级

isAlive()

测试这个线程是否还处于活动状态。
什么是活动状态呢?
活动状态就是线程已经启动且尚未终止。线程处于正在运行或准备运行的状态。

sleep(long millis)

使当前正在执行的线程以指定的毫秒数“休眠”(暂时停止执行),具体取决于系统定时器和调度程序的精度和准确性。

interrupt()

中断这个线程。

interrupted() 和isInterrupted()

interrupted():测试当前线程是否已经是中断状态,执行后具有将状态标志清除为false的功能

isInterrupted(): 测试线程Thread对相关是否已经是中断状态,但部清楚状态标志

setName(String name)

将此线程的名称更改为等于参数 name 。

isDaemon()

测试这个线程是否是守护线程。

setDaemon(boolean on)

将此线程标记为 daemon线程或用户线程。

join()

在很多情况下,主线程生成并起动了子线程,如果子线程里要进行大量的耗时的运算,主线程往往将于子线程之前结束,但是如果主线程处理完其他的事务后,需要用到子线程的处理结果,也就是主线程需要等待子线程执行完成之后再结束,这个时候就要用到join()方法了。

join()的作用是:“等待该线程终止”,这里需要理解的就是该线程是指的主线程等待子线程的终止。也就是在子线程调用了join()方法后面的代码,只有等到子线程结束了才能执行

yield()

yield()方法的作用是放弃当前的CPU资源,将它让给其他的任务去占用CPU时间。注意:放弃的时间不确定,可能一会就会重新获得CPU时间片。

setPriority(int newPriority)

更改此线程的优先级

停止一个线程

stop(),suspend(),resume()(仅用于与suspend()一起使用)这些方法已被弃用,所以我这里不予讲解。

使用interrupt()方法

我们上面提到了interrupt()方法,先来试一下interrupt()方法能不能停止线程
MyThread.java

public class MyThread extends Thread {
    @Override
    public void run() {
        super.run();
        for (int i = 0; i < 5000000; i++) {
            System.out.println("i=" + (i + 1));
        }
    }
}

Run.java

public class Run {

    public static void main(String[] args) {
        try {
            MyThread thread = new MyThread();
            thread.start();
            Thread.sleep(2000);
            thread.interrupt();
        } catch (InterruptedException e) {
            System.out.println("main catch");
            e.printStackTrace();
        }
    }

}

运行上诉代码你会发现,线程并不会终止。

针对上面代码的一个改进:

interrupted()方法判断线程是否停止,如果是停止状态则break

MyThread.java

public class MyThread extends Thread {
    @Override
    public void run() {
        super.run();
        for (int i = 0; i < 500000; i++) {
            if (this.interrupted()) {
                System.out.println("已经是停止状态了!我要退出了!");
                break;
            }
            System.out.println("i=" + (i + 1));
        }
        System.out.println("看到这句话说明线程并未终止------");
    }
}

Run.java

public class Run {

    public static void main(String[] args) {
        try {
            MyThread thread = new MyThread();
            thread.start();
            Thread.sleep(2000);
            thread.interrupt();
        } catch (InterruptedException e) {
            System.out.println("main catch");
            e.printStackTrace();
        }
        System.out.println("end!");
    }

}

运行结果:
i=437968
i=437968
i=437968
...
end!
已经是停止状态了!我要退出了!
看到这句话说明线程并未终止

for循环虽然停止执行了,但是for循环下面的语句还是会执行,说明线程并未被停止。

使用return终止线程

MyThread.java

public class MyThread extends Thread {

    @Override
    public void run() {
            while (true) {
                if (this.isInterrupted()) {
                    System.out.println("ֹͣ停止了!");
                    return;
                }
                System.out.println("timer=" + System.currentTimeMillis());
            }
    }

}

Run.java

public class Run {

    public static void main(String[] args) throws InterruptedException {
        MyThread t=new MyThread();
        t.start();
        Thread.sleep(2000);
        t.interrupt();
    }

}

运行结果输出停止了后就没有继续输出,线程的确被终止了

线程的优先级

每个线程都具有各自的优先级,线程的优先级可以在程序中表明该线程的重要性,如果有很多线程处于就绪状态,系统会根据优先级来决定首先使哪个线程进入运行状态。但这个并不意味着低
优先级的线程得不到运行,而只是它运行的几率比较小,如垃圾回收机制线程的优先级就比较低。所以很多垃圾得不到及时的回收处理。

线程优先级具有继承特性比如A线程启动B线程,则B线程的优先级和A是一样的。

线程优先级具有随机性也就是说线程优先级高的不一定每一次都先执行完。

Thread类中包含的成员变量代表了线程的某些优先级。如Thread.MINPRIORITY(常数1),Thread.NORMPRIORITY(常数5),
Thread.MAXPRIORITY(常数10)。其中每个线程的优先级都在Thread.MINPRIORITY(常数1) 到Thread.MAXPRIORITY(常数10) 之间,在默认情况下优先级都是Thread.NORMPRIORITY(常数5)。

学过操作系统这门课程的话,我们可以发现多线程优先级或多或少借鉴了操作系统对进程的管理。

线程优先级具有继承特性测试代码:

MyThread1.java

public class MyThread1 extends Thread {
    @Override
    public void run() {
        System.out.println("MyThread1 run priority=" + this.getPriority());
        MyThread2 thread2 = new MyThread2();
        thread2.start();
    }
}

MyThread2.java

public class MyThread2 extends Thread {
    @Override
    public void run() {
        System.out.println("MyThread2 run priority=" + this.getPriority());
    }
}

Run.java

public class Run {
    public static void main(String[] args) {
        System.out.println("main thread begin priority="
                + Thread.currentThread().getPriority());
        Thread.currentThread().setPriority(6);
        System.out.println("main thread end   priority="
                + Thread.currentThread().getPriority());
        MyThread1 thread1 = new MyThread1();
        thread1.start();
    }
}

运行结果:
main thread begin priority=5
main thread end priority=6
MyThread1 run priority=6
MyThread2 run priority=6

Java多线程分类

多线程分类

用户线程:运行在前台,执行具体的任务,如程序的主线程、连接网络的子线程等都是用户线程

守护线程:运行在后台,为其他前台线程服务.也可以说守护线程是JVM中非守护线程的 “佣人”。

特点:一旦所有用户线程都结束运行,守护线程会随JVM一起结束工作

应用:数据库连接池中的检测线程,JVM虚拟机启动后的检测线程

最常见的守护线程:垃圾回收线程

如何设置守护线程?

可以通过调用Thead类的setDaemon(true)方法设置当前的线程为守护线程

注意事项:

  1. setDaemon(true)必须在start()方法前执行,否则会抛出IllegalThreadStateException异常
  1. 在守护线程中产生的新线程也是守护线程
  2. 不是所有的任务都可以分配给守护线程来执行,比如读写操作或者计算逻辑

MyThread.java

public class MyThread extends Thread {
    private int i = 0;

    @Override
    public void run() {
        try {
            while (true) {
                i++;
                System.out.println("i=" + (i));
                Thread.sleep(100);
            }
        } catch (InterruptedException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }
    }
}

Run.java

public class Run {
    public static void main(String[] args) {
        try {
            MyThread thread = new MyThread();
            thread.setDaemon(true);
            thread.start();
            Thread.sleep(5000);
            System.out.println("我离开thread对象也不再打印了,也就是停止了!");
        } catch (InterruptedException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }
    }
}

最后打印了主线程的我离开thread对象也不再打印了,也就是停止了!后,子线程的死循环输出也终止了

目录
相关文章
|
8天前
|
安全 Java
java 中 i++ 到底是否线程安全?
本文通过实例探讨了 `i++` 在多线程环境下的线程安全性问题。首先,使用 100 个线程分别执行 10000 次 `i++` 操作,发现最终结果小于预期的 1000000,证明 `i++` 是线程不安全的。接着,介绍了两种解决方法:使用 `synchronized` 关键字加锁和使用 `AtomicInteger` 类。其中,`AtomicInteger` 通过 `CAS` 操作实现了高效的线程安全。最后,通过分析字节码和源码,解释了 `i++` 为何线程不安全以及 `AtomicInteger` 如何保证线程安全。
java 中 i++ 到底是否线程安全?
|
2天前
|
存储 设计模式 分布式计算
Java中的多线程编程:并发与并行的深度解析####
在当今软件开发领域,多线程编程已成为提升应用性能、响应速度及资源利用率的关键手段之一。本文将深入探讨Java平台上的多线程机制,从基础概念到高级应用,全面解析并发与并行编程的核心理念、实现方式及其在实际项目中的应用策略。不同于常规摘要的简洁概述,本文旨在通过详尽的技术剖析,为读者构建一个系统化的多线程知识框架,辅以生动实例,让抽象概念具体化,复杂问题简单化。 ####
|
3天前
|
Java 开发者
在Java多线程编程的世界里,Lock接口正逐渐成为高手们的首选,取代了传统的synchronized关键字
在Java多线程编程的世界里,Lock接口正逐渐成为高手们的首选,取代了传统的synchronized关键字
19 4
|
3天前
|
消息中间件 供应链 Java
掌握Java多线程编程的艺术
【10月更文挑战第29天】 在当今软件开发领域,多线程编程已成为提升应用性能和响应速度的关键手段之一。本文旨在深入探讨Java多线程编程的核心技术、常见问题以及最佳实践,通过实际案例分析,帮助读者理解并掌握如何在Java应用中高效地使用多线程。不同于常规的技术总结,本文将结合作者多年的实践经验,以故事化的方式讲述多线程编程的魅力与挑战,旨在为读者提供一种全新的学习视角。
23 3
|
10天前
|
安全 Java
在 Java 中使用实现 Runnable 接口的方式创建线程
【10月更文挑战第22天】通过以上内容的介绍,相信你已经对在 Java 中如何使用实现 Runnable 接口的方式创建线程有了更深入的了解。在实际应用中,需要根据具体的需求和场景,合理选择线程创建方式,并注意线程安全、同步、通信等相关问题,以确保程序的正确性和稳定性。
|
4天前
|
安全 Java 调度
Java中的多线程编程入门
【10月更文挑战第29天】在Java的世界中,多线程就像是一场精心编排的交响乐。每个线程都是乐团中的一个乐手,他们各自演奏着自己的部分,却又和谐地共同完成整场演出。本文将带你走进Java多线程的世界,让你从零基础到能够编写基本的多线程程序。
17 1
|
8天前
|
缓存 Java 调度
Java中的多线程编程:从基础到实践
【10月更文挑战第24天】 本文旨在为读者提供一个关于Java多线程编程的全面指南。我们将从多线程的基本概念开始,逐步深入到Java中实现多线程的方法,包括继承Thread类、实现Runnable接口以及使用Executor框架。此外,我们还将探讨多线程编程中的常见问题和最佳实践,帮助读者在实际项目中更好地应用多线程技术。
17 3
|
10天前
|
监控 安全 Java
Java多线程编程的艺术与实践
【10月更文挑战第22天】 在现代软件开发中,多线程编程是一项不可或缺的技能。本文将深入探讨Java多线程编程的核心概念、常见问题以及最佳实践,帮助开发者掌握这一强大的工具。我们将从基础概念入手,逐步深入到高级主题,包括线程的创建与管理、同步机制、线程池的使用等。通过实际案例分析,本文旨在提供一种系统化的学习方法,使读者能够在实际项目中灵活运用多线程技术。
|
8天前
|
缓存 安全 Java
Java中的多线程编程:从基础到实践
【10月更文挑战第24天】 本文将深入探讨Java中的多线程编程,包括其基本原理、实现方式以及常见问题。我们将从简单的线程创建开始,逐步深入了解线程的生命周期、同步机制、并发工具类等高级主题。通过实际案例和代码示例,帮助读者掌握多线程编程的核心概念和技术,提高程序的性能和可靠性。
10 2
|
9天前
|
Java
Java中的多线程编程:从基础到实践
本文深入探讨Java多线程编程,首先介绍多线程的基本概念和重要性,接着详细讲解如何在Java中创建和管理线程,最后通过实例演示多线程的实际应用。文章旨在帮助读者理解多线程的核心原理,掌握基本的多线程操作,并能够在实际项目中灵活运用多线程技术。