Java 多线程编程(入门)

简介: Java 多线程编程(入门)

一、简单介绍 Thread类

       线程是操作系统的概念。操作系统给线程的一些相关操作,提供了一系列的API让用户使用(例如 Linux 的 pthread 库)。

       这些系统原生的 API 是用 C语言编写的,而Java 为了能够方便使用这些 API, 就把这些 API 给封装成 Java 风格的类。

这个类就是 Java标准库中的 Thread 类

Thread 类可以视为是对操作系统提供的 API 进行了进一步的封装和抽象

【1】Thread类中一些常用的方法

  🌑start 方法

调用 start() 方法用来启动一个线程。当我们创建一个线程后,只有调用 start() 方法才能启动,并执行一些任务。

  🌒run 方法

run() 方法是不需要用户调用的。run() 方法相当于线程他的本质工作,当线程通过 start() 启动后,线程会自动执行 run() 内的任务。

注意:继承Thread类时,必须重写run方法,在run方法内自定义要执行的任务

🌓sleep 方法

1. sleep(long ms) //参数为毫秒
2. sleep(long ms,int nanoseconds)//第一个参数为毫秒,第二个参数为纳秒

sleep() 方法相当于让线程休眠

注意:使用 sleep方法是要处理一下异常!

【2】编写一个简单多线程程序(入门)

如果我们想创建一个线程并让它不断打印 “hello world”的任务。

首先:我们可以自己创建一个线程类(MyThread) 继承 Thread 类


第二步:重写 run() 方法,把我们想要线程执行的任务写入 run() 方法内部,如下

class MyThread extends Thread{
    @Override
    public void run() {
        System.out.println("hello thread!");
    }
}

第三步:在 main函数中创建名为 MyThread的线程,并调用 start() 方法启动该线程

public class Demo1 {
    public static void main(String[] args){
        MyThread myThread = new MyThread();
        myThread.start();
    }
}

这样我们就创建了一个线程啦。

在 Java 中,一个 Java 程序相当于一个进程,而 main函数相当于 主线程。我们创建的线程 和 主线程都是属于进程!!

每个线程都是一个独立的执行流

多个线程之间是 “并发” 执行的

  为了方便观察多线程的执行法过程,我们在 main函数 中也写上打印任务,并分别调用 sleep 方法,方便我们观察。

package threading;
class MyThread extends Thread{
    @Override
    public void run() {
        while(true){
            System.out.println("hello thread!");
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                throw new RuntimeException(e);
            }
        }
    }
}
//多线程创建实例
public class Demo1 {
    public static void main(String[] args) throws InterruptedException {
        MyThread myThread = new MyThread();
        myThread.start();
        while(true){
            System.out.println("hello main");
            Thread.sleep(1000);
        }
    }
}

结果如下:

   

我们会发现 main主线程 和 我们创建的线程是并发执行的(并发+并行),并不是串行执行的。

我们还可以使用 jconsole 命令观察线程

jconsole 命令查找可以查看:使用 jconsole 命令观察线程


jconsole 命令查找可以查看:使用 jconsole 命令观察线程

二、Java中创建多线程的方法(重点面试题)

1.继承 Thread 类

上述给大家演示的代码就是继承 Thread 类创建线程的方法,这里就不再赘述了。

2.实现 Runnable 接口,重写 run

先创建一个实现 Runnable 接口的类,实例化后作为参数传递给 Thread 构造方法。

class MyRunnable implements Runnable{
    @Override
    public void run() {
        while(true){
            ...
        }
    }
}
public class Demo2 {
    public static void main(String[] args) {
        MyRunnable runnable = new MyRunnable();
        Thread t = new Thread(runnable);
        t.start();
        while(true){
            System.out.println("hello main");
        }
    }
}

把任务提取出来,目的仍然是为了 解耦合 !

前面继承Thread 协防,就把线程要完成的工作,和线程本身,耦合在一起了

假设未来要对这个代码进程调整(不用多线程了,用其他方式),代码改动就比较大


而 Runnable 这种写法,就只是需要把 Runnable 传给其他的实体即可!!

3.使用匿名内部类,实现 创建 Thread 子类的方式

package threading;
public class Demo3 {
    public static void main(String[] args) {
        Thread t = new Thread(){
            public void run(){
                while(true){
                    System.out.println("hello thread");
                    try {
                        Thread.sleep(1000);
                    } catch (InterruptedException e) {
                        throw new RuntimeException(e);
                    }
                }
            }
        };
        t.start();
    }
}

4.使用匿名内部类,实现 Runnable 接口的方法

在 Thread 的构造方法的参数里面就地创建了一个匿名内部类

public class Demo4 {
    public static void main(String[] args) {
        Thread t = new Thread(new Runnable() {
            @Override
            public void run() {
                while (true) {
                    System.out.println("hello thread");
                    try {
                        Thread.sleep(1000);
                    } catch (InterruptedException e) {
                        throw new RuntimeException(e);
                    }
                }
            }
        });
        t.start();
    }
}

匿名内部类的实例,作为构造方法的参数

5.lambda 表达式【推荐】

lambda 本质上是一个 “匿名函数”

语法格式如下:

 Thread t = new Thread(()->{
    //... 
 });

():内代表函数的形参  {}:代表函数体

-> 特殊语法,表示它是一个 lambda

public class Demo5 {
    public static void main(String[] args) {
        Thread t = new Thread(() -> {
            while(true){
                System.out.println("hello thread");
                try {
                    Thread.sleep(1000);
                } catch (InterruptedException e) {
                    throw new RuntimeException(e);
                }
            }
        });
    }
}

注意:创建线程并不知道以上五种方式,不过大家知道这些就已经足够了

三、简单分析多线程编程提升效率

观察多线程在一些场合下,并行执行提升的代码运行速度的效率

System.currentTimeMillis():获取当前的时间戳。

serial 串行的完成一下运算,concurrency  使用两个线程并行执行相同操作。

package threading;
public class Demo6 {
    public static final long COUNT = 10_0000_0000L;
    public static void main(String[] args) throws InterruptedException {
        serial();
        concurrency();
    }
    // 串行执行任务
    public static void serial(){
        // 记录 ms 级别的时间戳
        long beg = System.currentTimeMillis();
        long a = 0;
        for(long i = 0;i < COUNT;i++){
            a++;
        }
        a= 0;
        for (int i = 0; i < COUNT; i++) {
            a++;
        }
        long end = System.currentTimeMillis();
        System.out.println("执行的时间间隔" + (end - beg) + " ms");
    }
    // 并发执行任务
    public static void concurrency() throws InterruptedException {
        long beg = System.currentTimeMillis();
        Thread t1 = new Thread(() -> {
            long a = 0;
            for (int i = 0; i < COUNT; i++) {
                a++;
            }
        });
        Thread t2 = new Thread(() -> {
            long a = 0;
            for (int i = 0; i < COUNT; i++) {
                a++;
            }
        });
        t1.start();
        t2.start();
        t1.join();
        t2.join();
        long end = System.currentTimeMillis();
        System.out.println("执行的时间间隔" + (end - beg) + " ms");
    }
}

 在main 中调用 t1.join() 效果就是让 main 线程阻塞,一直到 t1 执行完 run , mian才继续执行!!

由结果可知,在相同运算操作下,并行执行大致能比串行执行快1倍左右。但是并行执行提升代码速度并不是没有代价的,比如运算操作不准确等,这些就需要我们更加深度的学习。


相关文章
|
4天前
|
设计模式 Java 开发者
Java多线程编程的陷阱与解决方案####
本文深入探讨了Java多线程编程中常见的问题及其解决策略。通过分析竞态条件、死锁、活锁等典型场景,并结合代码示例和实用技巧,帮助开发者有效避免这些陷阱,提升并发程序的稳定性和性能。 ####
|
4天前
|
缓存 Java 开发者
Java多线程编程的陷阱与最佳实践####
本文深入探讨了Java多线程编程中常见的陷阱,如竞态条件、死锁和内存一致性错误,并提供了实用的避免策略。通过分析典型错误案例,本文旨在帮助开发者更好地理解和掌握多线程环境下的编程技巧,从而提升并发程序的稳定性和性能。 ####
|
7天前
|
数据采集 存储 数据处理
Python中的多线程编程及其在数据处理中的应用
本文深入探讨了Python中多线程编程的概念、原理和实现方法,并详细介绍了其在数据处理领域的应用。通过对比单线程与多线程的性能差异,展示了多线程编程在提升程序运行效率方面的显著优势。文章还提供了实际案例,帮助读者更好地理解和掌握多线程编程技术。
|
4天前
|
安全 Java 开发者
Java中的多线程编程:从基础到实践
本文深入探讨了Java多线程编程的核心概念和实践技巧,旨在帮助读者理解多线程的工作原理,掌握线程的创建、管理和同步机制。通过具体示例和最佳实践,本文展示了如何在Java应用中有效地利用多线程技术,提高程序性能和响应速度。
27 1
|
6天前
|
API Android开发 iOS开发
深入探索Android与iOS的多线程编程差异
在移动应用开发领域,多线程编程是提高应用性能和响应性的关键。本文将对比分析Android和iOS两大平台在多线程处理上的不同实现机制,探讨它们各自的优势与局限性,并通过实例展示如何在这两个平台上进行有效的多线程编程。通过深入了解这些差异,开发者可以更好地选择适合自己项目需求的技术和策略,从而优化应用的性能和用户体验。
|
12天前
|
安全 Java 开发者
Java 多线程并发控制:深入理解与实战应用
《Java多线程并发控制:深入理解与实战应用》一书详细解析了Java多线程编程的核心概念、并发控制技术及其实战技巧,适合Java开发者深入学习和实践参考。
|
11天前
|
存储 安全 Java
Java多线程编程中的并发容器:深入解析与实战应用####
在本文中,我们将探讨Java多线程编程中的一个核心话题——并发容器。不同于传统单一线程环境下的数据结构,并发容器专为多线程场景设计,确保数据访问的线程安全性和高效性。我们将从基础概念出发,逐步深入到`java.util.concurrent`包下的核心并发容器实现,如`ConcurrentHashMap`、`CopyOnWriteArrayList`以及`BlockingQueue`等,通过实例代码演示其使用方法,并分析它们背后的设计原理与适用场景。无论你是Java并发编程的初学者还是希望深化理解的开发者,本文都将为你提供有价值的见解与实践指导。 --- ####
|
5天前
|
Java API 数据库
Java 反射机制:动态编程的 “魔法钥匙”
Java反射机制是允许程序在运行时访问类、方法和字段信息的强大工具,被誉为动态编程的“魔法钥匙”。通过反射,开发者可以创建更加灵活、可扩展的应用程序。
|
2月前
|
存储 消息中间件 资源调度
C++ 多线程之初识多线程
这篇文章介绍了C++多线程的基本概念,包括进程和线程的定义、并发的实现方式,以及如何在C++中创建和管理线程,包括使用`std::thread`库、线程的join和detach方法,并通过示例代码展示了如何创建和使用多线程。
48 1
C++ 多线程之初识多线程
|
2月前
|
Java 开发者
在Java多线程编程中,创建线程的方法有两种:继承Thread类和实现Runnable接口
【10月更文挑战第20天】在Java多线程编程中,创建线程的方法有两种:继承Thread类和实现Runnable接口。本文揭示了这两种方式的微妙差异和潜在陷阱,帮助你更好地理解和选择适合项目需求的线程创建方式。
20 3