Java中的多线程

最新推荐文章于 2022-07-29 23:18:05 发布
最新推荐文章于 2022-07-29 23:18:05 发布
阅读量508 收藏
点赞数
分类专栏： java 文章标签： java thread 多线程
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_40576874/article/details/109600935
版权

Java中的多线程

目录

线程基础

线程是程序运行的基本执行单元。当操作系统（不包括单线程的操作系统，如微软早期的DOS）在执行一个程序时，会在系统中建立一个进程，而在这个进程中，必须至少建立一个线程（这个线程被称为主线程）作为这个程序运行的入口点。因此，在操作系统中运行的任何程序都至少有一个主线程。

一个进程中可以有一个或多个线程，进程和进程之间不共享内存，也就是说系统中的进程是在各自独立的内存空间中运行的。而一个进程中的线程可以共享系统分派给这个进程的内存空间。

线程不仅可以共享进程的内存，而且还拥有一个属于自己的内存空间，这段内存空间也叫做线程栈，是在建立线程时由系统分配的，主要用来保存线程内部所使用的数据，如线程执行函数中所定义的变量。

创建线程

使用Thread创建线程

Thread类的构造函数

public Thread();
public Thread(String name);
public Thread(Runnable target);
public Thread(ThreadGroup group, Runnable target);
public Thread(ThreadGroup group, Runnable target, String name,
              long stackSize) ;
public Thread(ThreadGroup group, String name) ;
public Thread(Runnable target, String name);
public Thread(ThreadGroup group, Runnable target, String name) ;

public Thread(ThreadGroup group, Runnable target, String name,
              long stackSize, boolean inheritThreadLocals) ;

参数说明：

  • Runnable target：实现了Runnable接口的类的实例。
  • String name：线程的名字，此名字可以在建立Thread实例后通过Thread类的setName方法设置。如果不设置线程的名字，线程就使用默认的线程名：Thread-N，N是线程建立的顺序，是一个不重复的正整数。
  • ThreadGroup group：当前建立的线程所属的线程组。如果不指定线程组，所有的线程都被加到一个默认的线程组中。
  • long stackSize：线程栈的大小。

通过Thread类的start()方法来执行线程代码

实例

public class MyThread extends Thread {
    public void run(){
        System.out.println(this.getName());
    }      
    public static void main(String[] args) {

        Thread th1=new MyThread();
        Thread th2=new MyThread();
        th1.start();//启动线程
        th2.start();//启动线程
    }     
}

运行结果

Thread-0
Thread-1

使用Runnable接口创建线程

public class MyRunnable implements Runnable {
   
    public void run(){
        System.out.println(Thread.currentThread().getName());
    }
    public static void main(String[] args) {

        MyRunnable rb1=new MyRunnable();
        MyRunnable rb2=new MyRunnable();
        Thread th1=new Thread(rb1);
        Thread th2=new Thread(rb2);
        th1.start();
        th2.start();     
    }     
}

运行结果

Thread-0
Thread-1

控制线程

使用join()方法

Thread类的join()方法，此方法的功能是使异步执行的线程变成同步执行。而使用join()方法后，直到这个线程退出，程序才会往下执行。

加入join()方法后的代码实例

public class MyThread extends Thread {
    
    public void run(){
        try{
            sleep(3000);
            System.out.println(this.getName());
        }catch(InterruptedException e){
            e.printStackTrace();
        }
    }

    public static void main(String[] args){

        Thread th1=new MyThread();
        th1.start();
        th1.join();
        System.out.println("hello");    
    }     
}

运行结果

Thread-0
hello

即使在线程中设置了3秒的等待，加入了join方法后，也要等线程运行完了才运行join后面的程序。

没有加入join方法的代码示例

public class MyThread extends Thread {
    
    public void run(){
        try{
            sleep(3000);
            System.out.println(this.getName());

        }catch(InterruptedException e){
            e.printStackTrace();
        }
    }
    public static void main(String[] args) {

        Thread th1=new MyThread();
        th1.start();     
        System.out.println("hello");  
    }     
}

运行结果

hello
Thread-0

可以看出没有加入join()方法，线程和主线程异步进行。

总结：当需要线程中的返回值的时候，就可以加上join()方法，使得线程与主线程是同步进行的。

后台线程（守护线程）

有一种线程是在后台运行的，其任务是为其他的线程提供服务，这种线程被称为“后台线程（Daemon Thread）”，又称为“守护线程”或“精灵线程”。JVM的垃圾回收线程就是典型的后台线程，后台线程有一个非常明显的特征——如果所有的前台线程都死亡，后台线程会自动死亡。

实例
setDaemon()

public class MyThread extends Thread {
    
    public void run(){
        for(int i=0;i<1000;i++){
            System.out.println(this.getName()+" "+i);
        }
    }

    public static void main(String[] args)  {

        Thread th1=new MyThread();
        th1.setDaemon(true);//设置为后台进程
        th1.start();

        for(int i=0;i<5;i++){
            System.out.println(Thread.currentThread().getName()+" "+i);
        }    
    }//main线程死亡     
}

运行结果

main 0
Thread-0 0
Thread-0 1
Thread-0 2
Thread-0 3
Thread-0 4
Thread-0 5
Thread-0 6
Thread-0 7
Thread-0 8
main 1
Thread-0 9
Thread-0 10
main 2
Thread-0 11
main 3
Thread-0 12
main 4
Thread-0 13
Thread-0 14
Thread-0 15
Thread-0 16
Thread-0 17
Thread-0 18
Thread-0 19
Thread-0 20
Thread-0 21
Thread-0 22
Thread-0 23
Thread-0 24
Thread-0 25
Thread-0 26
Thread-0 27
Thread-0 28
Thread-0 29

可以看出新建的线程是没有运行完的，当主线程main运行结束后，Thread-0也结束了没有继续运行。

睡眠线程

如果我们需要让当前正在执行的线程暂停一段时间，并进入阻塞状态，则可以通过调用Thread类的静态sleep方法实现，方法sleep有如下两种重载的形式。

//让当前正在执行的线程暂停millis毫秒，并进入阻塞状态，
public static native void sleep(long millis);
//让当前正在执行的线程暂停millis毫秒加nanos毫微秒，并进入阻塞状态
public static void sleep(long millis, int nanos);

实例

public class MyThread extends Thread {
    
    public void run(){
        for(int i=0;i<5;i++){
            System.out.println(this.getName()+" "+i);
        }
    }

    public static void main(String[] args)  throws InterruptedException{

        Thread th1=new MyThread();
        Thread th2=new MyThread(); 
        Thread th3=new MyThread(); 
        th1.start();       
        th2.start();
        Thread.sleep(100);//线程睡眠100毫秒
        th3.start();             
    }     
}

运行结果

Thread-1 0
Thread-0 0
Thread-1 1
Thread-0 1
Thread-1 2
Thread-0 2
Thread-1 3
Thread-0 3
Thread-1 4
Thread-0 4
Thread-2 0
Thread-2 1
Thread-2 2
Thread-2 3
Thread-2 4

可以看出线程Thread-0和Thread-1正常运行，线程Thread-2会等待200毫秒在运行。

线程同步

可以使用join()方法

实例

public class Demo {
    public static void main(String[] args)  throws Exception{
        Thread add=new AddThread();
        Thread de=new DeThread();
        add.start();
        add.join();
        de.start();
        de.join();
        System.out.println(Counter.count);   
    }     
}

class Counter{
    public static int count=0;
}

class AddThread extends Thread{
    public void run(){
        for(int i=0;i<10000;i++){
            Counter.count+=1;
        }
    }
}

class DeThread extends Thread{
    public void run(){
        for(int i=0;i<10000;i++){
            Counter.count-=1;
        }
    }
}

运行结果

0

假如没有使用join方法，最后的数据会是各种各样的，这样活导致数据不安全。

也可以使用synchronized进行加锁

为了一段代码的原子性，可以通过加锁和解锁的方式，格式如下：

synchronized(lock) {//加锁
...
}//解锁

实例

public class Demo {
    public static void main(String[] args)  throws Exception{
        Thread add=new AddThread();
        Thread de=new DeThread();
        add.start();
        de.start();
        de.join();
        System.out.println(Counter.count);        
     
    }     
}

class Counter{
    public static final Object lock = new Object();
    public static int count=0;
}

class AddThread extends Thread{
    public void run(){
        for(int i=0;i<10000;i++){
            synchronized(Counter.lock){
                Counter.count+=1;
            }        
        }
    }
}

class DeThread extends Thread{
    public void run(){
        for(int i=0;i<10000;i++){
            synchronized(Counter.lock){
                Counter.count-=1;
            }
        }
    }
}

运行结果

0

代码中加了de.join();只是为了让线程运行完了才打印，不然会出现其他的数字。

方法同步

为了增加线程的效率，可以使用synchronized对方法进行同步。

实例

public class Demo {
   
    public static void main(String[] args)  throws Exception{
        Counter c1=new Counter();
        Thread th1=new Thread(()->{c1.add();});
        Thread th2=new Thread(()->{c1.dec();});
        th1.start();
        th2.start();
        th2.join();
        System.out.println(Counter.count);       
     
    }     
}

class Counter{
    public static int count=0;
    
    public synchronized void add(){
         for(int i=0;i<10000;i++){    
            Counter.count+=1;   
            
        }
    }
    public synchronized void dec(){
        for(int i=0;i<10000;i++){    
            Counter.count-=1;             
        }
    }
}

运行结果

0

这样即使多个线程去操作同一个数也是数据安全的，通过合理的设计和数据封装可以让一个类变为“线程安全”。

总结

线程和函数的关系

任何一个线程在建立时都会执行一个函数，这个函数叫做线程执行函数。也可以将这个函数看做线程的入口点（类似于程序中的main函数）。无论使用什么语言或技术来建立线程，都必须执行这个函数（这个函数的表现形式可能不一样，但都会有一个这样的函数）。

在run方法中使用线程名时带来的问题

在调用start()方法前后都可以使用setName设置线程名，但在调用start()方法后使用setName修改线程名，会产生不确定性，也就是说可能在run()方法执行完后才会执行setName。如果在run()方法中要使用线程名，就会出现虽然调用了setName()方法，但线程名却未修改的现象，类Thread的start()方法不能多次调用，否则会抛出异常。

继承Thread类或实现Runnable接口方式的比较

当采用Runnable接口方式实现多线程时，线程类只是实现了Runnable接口，还可以继承其他类。

当采用继承Thread类方式的多线程时，劣势是因为线程类已经继承了Thread类，所以不能再继承其他父类；

start()和run()的区别

使用方法start()来启动线程
方法run()只是thread的一个普通方法调用

秃头_程序猿
关注
专栏目录
万字图解Java多线程
qq_35598736的博客
09-06 6万+
前言 java多线程我个人觉得是javaSe中最难的一部分，我以前也是感觉学会了，但是真正有多线程的需求却不知道怎么下手，实际上还是对多线程这块知识了解不深刻，不知道多线程api的应用场景，不知道多线程的运行流程等等，本篇文章将使用实例+图解+源码的方式来解析java多线程。 文章篇幅较长，大家也可以有选择的看具体章节，建议多线程的代码全部手敲，永远不要相信你看到的结论，自己编码后运行出来的，才是自己的。 什么是java多线程? 进程与线程 进程 当一个程序被运行，就开启了一个进程， 比如启动了qq，w.
Java 多线程的应用场景
热门推荐
才哈哈的博客主页
05-01 1万+
电影院新片首映，观影人数大量增加，为提高日营业额，线下售票窗口由原单窗口调整为3窗口，设计一段简单的程序模拟该售票过程。
Java中多线程的使用，龟兔赛跑
weixin_51733609的博客
07-29 2537
Java中多线程的使用，龟兔赛跑
java向多线程中传递参数的三种方法详细介绍
09-05
以下将详细介绍三种向Java多线程传递参数的方法。 1. **通过构造方法传递数据** 当创建Thread类或其子类的实例时，可以利用构造方法来传递数据。这些数据通常存储为类的成员变量，在`run()`方法中使用。例如： ``...
java多线程实现大批量数据导入源码
09-29
本项目以"java多线程实现大批量数据导入源码"为题，旨在通过多线程策略将大量数据切分，并进行并行处理，以提高数据处理速度。 首先，我们需要理解Java中的线程机制。Java通过`Thread`类来创建和管理线程。每个线程...
java多线程设计模式_java_设计模式_多线程_多线程课题_
09-29
Java多线程设计模式是Java开发中的核心概念，它涉及到如何高效、安全地在多个执行线程之间共享资源和协调任务。设计模式是解决特定问题的成熟方案，它们是编程经验的结晶，可以帮助开发者在面临多线程挑战时快速找到...
Java 高并发多线程编程系列案例代码
01-02
Java 高并发多线程编程系列案例代码 & 教程 & 面试题集锦! !! 包括但不限于线程安全性, atomic包下相关类、CAS原理、Unsafe类、synchronized关键字等的使用及注意事项,
java中多线程统计时间_Java多线程下统计多个线程的运行时间
weixin_34321609的博客
02-25 1681
今天复习了一下java中Synchronized等关于多线程的问题。Synchronized是Java语言的关键字，当它用来修饰一个方法或者一个代码块的时候，能够保证在同一时刻最多只有一个线程执行该段代码。Java的每个对象都有一个内部锁，如果一个方法用synchronized关键字声明，那么对象的锁将保护整个方法。要调用该方法必须获得内部的对象锁。一、当两个并发线程访问同一个对象object中的...
java数组踩过的坑
秃头_程序猿的博客
10-20 8907
通过阅读本文，可以了解如下的一些信息：了解在运用数组的时候，可能会犯的一些基本的错误（如数组中保存类型的统一）；了解数组的常见异常，并且知道如何捕获这些异常（如超出索引异常、空指针异常）。
Java容器的常用组件
秃头_程序猿的博客
10-30 3421
Frame组件的特点： - Frame对象有标题，允许通过拖拉来改变窗口的位置、大小 - 初始化时为不可见，可用setVisible(true)使其显示出来 - 默认使用BorderLayout作为其布局管理器 Panel是AWT中的一个典型的容器，它不能独立存在、必须放在其他容器中的容器。该区域中可以继续盛装其他组件。Panel容器存在的意义在于为其他组件提供空间，Panel容器具有如下3个特点。
Java中URLDecoder和URLEncoder的简单使用
秃头_程序猿的博客
11-06 821
URLDecoder类和URLEncoder类的功能是，完成普通字符串和application/x-www-form-urlencoded MIME 字符串之间的相互转换。application/x-www-form-urlencoded MIME 虽然不是普通的字符串，但是在现实应用中经常见到，例如搜索引擎网址中看似是乱码的内容，如图所示。
Java中InetAddress类的简单使用
秃头_程序猿的博客
11-05 750
InetAddress类的简单使用，在Java中使用类InetAddress来表示IP地址，在类InetAddress下还有如下两个子类： - Inet4Address：代表InternetProtocolversion4(IPv4)地址 - Inet6Address：InternetProtocolversion6(IPv6)地址 InetAddress没有构造函数，提供了两个函数来创建实例： - getByName(String host)：根据主机获取对应的InetAddress
【标识符+关键字+字符串】Java基本语法中篇
秃头_程序猿的博客
10-16 636
通过阅读本文可以了解如下信息：1. 如何命名合法的标识符；2.关键字和标识符的关系；3.怎么创建字符串，以及字符串的一些基本操作。字符串的内部类有许多操作，可以在Java String API中查询。
Java的布局管理器
秃头_程序猿的博客
11-01 484
FlowLayout 在默认的情况下，AWT的布局管理器是FlowLayout，这个管理器将组件从左到右、从上到下顺序摆放，它将所有的组件摆放在居中位置。BorderLayout 通过BorderLayout布局方式可以将窗口划成上、下、左、右、中5个区域，普通组件可以被放置在这5个区域中的任意一个。当改变使用BorderLayout的容器大小时，上、下和中区域可以水平调整，而左、右和中间区域可以垂直调整。在使用BorderLayout时需要注意如下两点。
Java中的TCP编程
秃头_程序猿的博客
11-08 410
TCP/IP通信协议是一种可靠的网络协议，能够在通信的两端各建立一个Socket，从而在通信的两端之间形成网络虚拟链路。一旦建立了虚拟的网络链路，两端的程序就可以通过虚拟链路进行通信。 ## Socket 在客户端可以使用Socket的构造器来连接到指定服务器，在Socket中可以使用如下两个构造函数。 - Socket( InetAddress/String remoteAddress, int port)：创建连接到指定远程主机、远程端口的Socket，该构造器没有指定本地地址、本地端口，默认
Java中的UDP编程
秃头_程序猿的博客
11-10 359
Java中的UDP编程 Java为我们提供了DatagramSocket对象作为基于UDP协议的Socket，可以使用DatagramPacket代表DatagramSocket发送或接收数据报 DatagramSocket本身只是码头，不维护状态，不能产生I/O流，它的唯一作用就是接收和发送数据报： - send();发送数据包 - receive();接收数据包 Java使用DatagramPacket来代表数据报，DatagramSocke
Java中多线程的使用
最新发布
08-07
### 回答1： Java 中的多线程可以通过创建 Thread 类的实例来实现。具体步骤如下： 1. 创建一个实现 Runnable 接口的类，该类实现 run() 方法。 ```java public class MyRunnable implements Runnable { public void run() { // 执行线程的操作 } } ``` 2. 创建一个 Thread 实例，并将实现了 Runnable 接口的类作为构造函数的参数。 ```java MyRunnable myRunnable = new MyRunnable(); Thread thread = new Thread(myRunnable); ``` 3. 启动线程。 ```java thread.start(); ``` 此外，还可以通过继承 Thread 类来实现多线程。具体步骤如下： 1. 创建一个继承自 Thread 类的类，重写 run() 方法。 ```java public class MyThread extends Thread { public void run() { // 执行线程的操作 } } ``` 2. 创建 MyThread 的实例。 ```java MyThread myThread = new MyThread(); ``` 3. 启动线程。 ```java myThread.start(); ``` 在多线程的使用中，需要注意线程安全的问题，比如共享变量的访问、同步操作等。可以使用 synchronized 关键字或者 Lock 接口来保证线程安全。 ### 回答2： 在Java中，多线程的使用是指程序同时运行多个线程，每个线程执行自己的任务。Java中多线程的使用可以带来以下几点好处： 1. 提高程序的效率：多线程可以对多个任务进行并发处理，提高程序的运行效率。例如，可以将网络请求和UI界面分别放在两个不同的线程中，这样即使网络请求比较耗时，UI界面也能进行响应，不会出现界面假死的情况。 2. 充分利用系统资源：多线程可以充分利用系统的处理器资源，提高系统的利用率。在多核处理器上运行多个线程，可以让每个核心都得到充分利用，提高系统的整体性能。 3. 实现异步编程：多线程可以实现异步编程，即一个线程执行后续操作，不需要等待另一个线程的完成。这样可以提高程序的响应速度。例如，可以使用多线程来进行文件下载，下载过程中可以同时进行其他操作。 4. 处理复杂的并发情况：在一些需要处理多个并发操作的场景中，多线程可以提供更好的解决方案。例如，在并发访问共享资源的情况下，使用线程锁可以保证对共享资源的安全访问，避免数据冲突和一致性问题。 Java中使用多线程可以通过创建Thread类的实例或者实现Runnable接口来实现。通过继承Thread类来创建线程，需要重写run方法，在run方法中定义线程要执行的任务。通过实现Runnable接口来创建线程，需要实现run方法，并将实现了Runnable接口的对象作为参数传递给Thread类的构造方法。 总之，Java中多线程的使用使得程序可以同时执行多个任务，提高了程序的效率和用户体验，并且能够处理复杂的并发情况。但需要注意多线程的安全性和线程之间的协作，避免出现数据冲突和一致性问题。 ### 回答3： Java中多线程的使用是指在一个程序中同时执行多个任务或者同时处理多个请求。多线程可以提高程序的并发性和响应性，可以将耗时的操作和任务分配给不同的线程来执行，从而提高程序的运行效率。 在Java中，多线程的使用主要依靠Thread类或者实现Runnable接口来创建线程。可以通过继承Thread类创建一个线程类，并重写run方法，在run方法中定义需要执行的任务；也可以实现Runnable接口，创建一个Runnable对象，然后将该对象作为参数传递给Thread类的构造方法，创建一个线程对象。 使用多线程的好处是可以充分利用处理器的多核特性，同时进行多个任务，提高程序的运行效率。多线程还可以提高程序的响应性，当程序中有耗时的操作时，可以将其放在一个独立的线程中执行，防止主线程被阻塞，提高用户体验。 然而，多线程的使用也存在一些问题。首先是线程安全问题，多个线程同时访问共享资源可能导致数据不一致或者数据损坏。为解决这个问题，可以使用同步机制，如synchronized关键字或Lock接口，保证在同一时间只有一个线程能够访问共享资源。其次，多线程的创建和销毁会消耗系统资源，如果线程数量过多，可能会影响系统性能。因此，在使用多线程时应该合理控制线程的数量。另外，线程之间的协调和通信也是一个值得关注的问题，可以使用wait、notify、join等方法来实现线程间的协作。 总之，Java中多线程的使用可以提高程序的并发性和响应性，但需要注意线程安全、资源消耗以及线程协调和通信等问题。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值