java多线程相关基础

最新推荐文章于 2024-10-17 10:27:13 发布
最新推荐文章于 2024-10-17 10:27:13 发布
阅读量342 收藏
点赞数 1
分类专栏： Java多线程 文章标签： 多线程 java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/u014633728/article/details/48226731
版权

今天我会将学习Java多线程的做个笔记，方便以后复习。

自定义一个线程（extends Thread）

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

主函数

MyThread thread = new MyThread();
        MyThread thread1 = new MyThread();
        thread.start();
        thread1.start();
        try {
            Thread.sleep(1000);
            System.out.println("------------------");
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        thread.run();
        thread1.run();

运行结果：

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

当run方式时，其实并非多线程，只是普通的执行了方法而已，start方法才是符合多线程。为什么？看源码

public synchronized void start() {
        if (threadStatus != 0)
            throw new IllegalThreadStateException();

        /* Notify the group that this thread is about to be started
         * so that it can be added to the group's list of threads
         * and the group's unstarted count can be decremented. */
        group.add(this);

        boolean started = false;
        try {
            start0();
            started = true;
        } finally {
            try {
                if (!started) {
                    group.threadStartFailed(this);
                }
            } catch (Throwable ignore) {
                /* do nothing. If start0 threw a Throwable then
                  it will be passed up the call stack */
            }
        }
    }

    private native void start0();

    /**
     * If this thread was constructed using a separate
     * <code>Runnable</code> run object, then that
     * <code>Runnable</code> object's <code>run</code> method is called;
     * otherwise, this method does nothing and returns.
     * <p>
     * Subclasses of <code>Thread</code> should override this method.
     *
     * @see     #start()
     * @see     #stop()
     * @see     #Thread(ThreadGroup, Runnable, String)
     */
    @Override
    public void run() {
        if (target != null) {
            target.run();
        }
    }

看到start0方法，有native进行修饰。简单地讲，一个native Method就是一个java调用非java代码的接口。一个native Method是这样一个java的方法：该方法的实现由非java语言实现，比如C。因为我们知道多线程是与操作系统有关的。

自定义一个线程(implements Runnable)

class MyRunnable implements Runnable{
    @Override
    public void run() {
        for(int i = 0 ; i < 5 ; i++)
            System.out.println(this.hashCode()+"--->"+i);
    }
}

主函数

    Thread t1 = new Thread(new MyRunnable());
    Thread t2 = new Thread(new MyRunnable());
    t1.start();
    t2.start();

结果我就不演示了。两者有什么区别，看接下来的小程序就明白了

class MyThread extends Thread {

    private int num;
    public MyThread(int num){
        this.num = num;
    }
    @Override
    public void run() {
        while(num >= 0 )
            System.out.println(this.getName()+"num数量--->"+(num--));
        super.run();
    }
}

class MyRunnable implements Runnable{
    private int num;
    public MyRunnable(int num){
        this.num = num;
    }
    @Override
    public void run() {
        while(num >= 0 )
            System.out.println(Thread.currentThread().getName()+"num数量--->"+(num--));
    }
}

public class Test {
    public static void main(String[] args) {
        int num = 3;        
        MyThread thread = new MyThread(num);
        MyThread thread1 = new MyThread(num);
        thread.start();
        thread1.start();
        try {
            Thread.sleep(1000);
            System.out.println("------------------");
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        MyRunnable mRun = new MyRunnable(num);
        Thread t1 = new Thread(mRun);
        Thread t2 = new Thread(mRun);
        t1.start();
        t2.start();
    }
}

结果

Thread-0num数量--->3
Thread-0num数量--->2
Thread-0num数量--->1
Thread-0num数量--->0
Thread-1num数量--->3
Thread-1num数量--->2
Thread-1num数量--->1
Thread-1num数量--->0
------------------
Thread-2num数量--->3
Thread-3num数量--->2
Thread-3num数量--->0
Thread-2num数量--->1

通过可以看到runnable对于num进行了我们想要的操作，两个线程操作统一个共享资源。就好像不同的售票窗口去买数据库总的票一样。总结一下Runnable的优点。

1）：适合多个相同的程序代码的线程去处理同一个资源
2）：可以避免java中的单继承的限制
3）：增加程序的健壮性，代码可以被多个线程共享，代码和数据独立。

看Thread的源码你会发现继承了Runnable接口

public
class Thread implements Runnable {
    /* Make sure registerNatives is the first thing <clinit> does. */
    private static native void registerNatives();
    static {
        registerNatives();
    }...
    ...
  }

线程的相关方法

 public final native boolean isAlive();//是否活着
 /*
 *join方法的功能就是使异步执行的线程变成同步执行
 *使用join方法后，直到这个线程退出，程序才会往下执行。
 */
 public final synchronized void join(int millis );//等待该线程终止的时间最长为 millis 毫秒。
 public void interrupt();//中断
 /**
 *不要误以为优先级越高就先执行。谁先执行还是取决于谁先去的CPU的资源
 * public final static int MIN_PRIORITY = 1;
 * public final static int NORM_PRIORITY = 5;
 * public final static int MAX_PRIORITY = 10;
 */
 public final void setPriority(int newPriority);
 /**
 yield()应该做的是让当前运行线程回到可运行状态，以允许具有相同优先级的其他线程获得运行机会。因此，使用yield()的目的是让相同优先级的线程之间能适当的轮转执行。但是，实际中无法保证yield()达到让步目的，因为让步的线程还有可能被线程调度程序再次选中。
 */
 public static native void yield();

看一下一般线程的生命周期图
这里写图片描述

守护线程和用户线程
这里我具体讲一下守护线程和用户线程 。
所谓守护线程，是指在程序运行的时候在后台提供一种通用服务的线程，比如垃圾回收线程就是一个很称职的守护者，并且这种线程并不属于程序中不可或缺的部分。因此，当所有的非守护线程结束时，程序也就终止了，同时会杀死进程中的所有守护线程。反过来说，只要任何非守护线程还在运行，程序就不会终止。
用户线程和守护线程两者几乎没有区别，唯一的不同之处就在于虚拟机的离开：如果用户线程已经全部退出运行了，只剩下守护线程存在了，虚拟机也就退出了。因为没有了被守护者，守护线程也就没有工作可做了，也就没有继续运行程序的必要了。将线程转换为守护线程可以通过调用Thread对象的setDaemon（true）方法来实现。
在使用守护线程时需要注意一下几点：
（1）thread.setDaemon（true）必须在thread.start（）之前设置，否则会跑出一个IllegalThreadStateException异常。你不能把正在运行的常规线程设置为守护线程。
（2）在Daemon线程中产生的新线程也是Daemon的。
（3）守护线程应该永远不去访问固有资源，如文件、数据库，因为它会在任何时候甚至在一个操作的中间发生中断。

class DaemonRunnable implements Runnable {

    @Override
    public void run() {
        System.out.println(Thread.currentThread().getName() + "开始运行");
        // 每隔一秒钟显示守护线程在运行

        int count = 1000;
        while (count > 0 && Thread.currentThread().isAlive()) {
            try {
                Thread.sleep(1000);
                System.out.println(Thread.currentThread().getName() + "正在运行");
                count--;
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
        System.out.println(Thread.currentThread().getName() + "结束运行");
    }

}

public class Test {
    public static void main(String[] args) {
        System.out.println("主线程开始运行");
        Thread thread = new Thread(new DaemonRunnable(), "守护线程");
        thread.setDaemon(true);
        thread.start();
        try {
            Thread.sleep(5 * 1000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println("主线程退出运行");
    }
}

结果是当主线程作为唯一的用户线程退出后，守护线程也就退出，不会将“守护线程正在运行”打印1000次

主线程开始运行
守护线程开始运行
守护线程正在运行
守护线程正在运行
守护线程正在运行
守护线程正在运行
主线程退出运行

同步问题（synchronized）

有问题的程序

class MyRunnable implements Runnable {
    private int num;
    public MyRunnable(int num) {
        this.num = num;
    }
    @Override
    public void run() {
        while (num >= 0) {
            /*try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }*/
            System.out.println(Thread.currentThread().getName() + "num数量--->" + (num--));
        }
    }
}
public class Test {
    public static void main(String[] args) {
        int num = 5;
        MyRunnable mRun = new MyRunnable(num);
        Thread t1 = new Thread(mRun);
        Thread t2 = new Thread(mRun);
        Thread t3 = new Thread(mRun);
        t1.setName("线程1");
        t2.setName("线程2");
        t3.setName("线程3");
        t1.start();
        t2.start();
        t3.start();
    }
}

运行n遍后的结果：

线程2num数量--->5
线程2num数量--->4
线程2num数量--->3
线程2num数量--->2
线程2num数量--->1
线程2num数量--->0

没有问题呀！真的没有嘛，其实不然，那是因为run占用的时间太短了，真实的run一定是有比较长的。把Thead.sleep()方法打开后，问题就来了：

线程2num数量--->5
线程3num数量--->4
线程1num数量--->3
线程2num数量--->2
线程3num数量--->1
线程1num数量--->0
线程2num数量--->-1
线程3num数量--->-2

为什么？因为多个线程可以操作num–,当线程1操作时num=0,可是线程2，线程3已经进入while(num>0)的判断中，当时num确实是>0的，所以出现了-1，-2的结果。如何处理？synchronized 当它用来修饰一个方法或者一个代码块的时候，能够保证在同一时刻最多只有一个线程执行该段代码

class MyRunnable implements Runnable {
    private int num;

    public MyRunnable(int num) {
        this.num = num;
    }

    @Override
    public void run() {
        des();
    }

    public synchronized void des() {
        while (num >= 0) {
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println(Thread.currentThread().getName() + "num数量--->" + (num--));
        }
    }
}

结果

线程2num数量--->5
线程2num数量--->4
线程2num数量--->3
线程2num数量--->2
线程2num数量--->1
线程2num数量--->0

下面浅显的讲一下线程的可见性和原子性，以及synchronized，volatile实现共享变量的原理

首先了解一下Java内存模型（JMM）:围绕着在并发过程中如何处理可见性、原子性、有序性这三个特性而建立的模型。

可见性：JMM提供了volatile变量定义、final、synchronized块来保证可见性。
1.synchronized如何实现可见性：
在加锁前，清空工作内存中的共享变量的值，重新从主内存中去最新的共享变量的值。
在解锁前，将最新的工作内存中的共享变量的值刷到主内存中。
2.volatile如何实现可见性
深入的讲：volatile通过加入内存屏障和禁止指令重排序的方法实现可见性。
通俗的讲：volatile修饰的变量，每次被线程访问时都要从主内存中去，当变量发生变化时，都要强制刷的主内存中。
3.final如何实现可见性：
这个最简单，所有的final变量都是不可变的，当然是可见的

原子性：JMM提供保证了访问基本数据类型的原子性（其实在写一个工作内存变量到主内存是分主要两步：store、write），但是实际业务处理场景往往是需要更大的范围的原子性保证，所以模型也提供了synchronized块来保证。对比一下下面两个例子

public class Test {
    public volatile int num = 0;

    public void inc() {
        num++;
    }

    public static void main(String[] args) {
        Test test = new Test();
        for (int i = 0; i < 500; i++) {
            Thread thread = new Thread(new Runnable() {
                public void run() {
                    test.inc();
                }
            });
            thread.start();
        }
        // 如果还有子线程在运行，主线程就让出CPU资源，
        // 直到所有的子线程都运行完了，主线程再继续往下执行
        while (Thread.activeCount() > 1) {
            Thread.yield();
        }
        System.out.println("num = " + test.num);
    }
}

多运行几遍你会发现

num = 499

这是因为volatile不具有原子性，num++分为3个步骤：取num,num+1,num赋值回来。执行到任何一步都有可能被别的线程插入进来。导致结果num<=500。synchronized则不是这样，把这3个步骤看做一个原子操作。没有执行完是不会被别的线程抢占执行的。num一定等于500

public class Test {
    public int num = 0;

    public synchronized void inc() {
        num++;
    }

    public static void main(String[] args) {
        Test test = new Test();
        for (int i = 0; i < 500; i++) {
            Thread thread = new Thread(new Runnable() {
                public void run() {
                    test.inc();
                }
            });
            thread.start();
        }
        // 如果还有子线程在运行，主线程就让出CPU资源，
        // 直到所有的子线程都运行完了，主线程再继续往下执行
        while (Thread.activeCount() > 1) {
            Thread.yield();
        }
        System.out.println("num = " + test.num);
    }
}

结果

num = 500

其实多线程的内容还有很多。这篇博客的内容也是我在学习多线程的一些笔记而已。我也参考了一些资料。作为以后温习用吧!有不对的地方请多多指教。

帝王鲨
关注
专栏目录
java多线程读取多个文件的方法
08-25
首先，本文涉及到的核心类是`Thread`类，这是Java中实现多线程的基础。在Java中，通过继承`Thread`类或者实现`Runnable`接口，可以创建一个线程。由于`Thread`类本身就是实现了`Runnable`接口的，因此这里继承`...
Java多线程干货系列（1）Java多线程基础编程开发技术
11-22
Java多线程是Java编程中的重要...以上内容仅涵盖了Java多线程基础编程的一部分知识点，实际开发中还需要关注更多的并发控制策略、性能优化和调试技巧。对于深入理解Java多线程，还需要学习和实践更多相关的高级特性。
从System.out.println()了解Java程序的工作原理
autumn20080101的专栏
01-19 1381
从System.out.println()了解Java程序的工作原理 更多 在Java编程中，我们常常用System.out.println()方法来输出字符串，也许我们都已经猜到println()是方法名，但System是什么，out又是什么呢？ 这里就涉及用到一个static关键字。如下图，其实System是java.lang里面的一个类。
Java多线程实战-实现多线程文件下载，支持断点续传、日志记录等功能
qq_35716689的博客
03-10 25万+
本文将介绍如何通过Java来实现一个多线程下载器。作者：牵着猫散步的鼠鼠
Java多线程（超详细！）
一只小菜鸡
05-13 13万+
1、什么是进程？什么是线程？ 进程是:一个应用程序（1个进程是一个软件）。 线程是：一个进程中的执行场景/执行单元。 注意：一个进程可以启动多个线程。 eg.对于java程序来说，当在DOS命令窗口中输入： java HelloWorld 回车之后。 会先启动JVM，而JVM就是一个进程。 JVM再启动一个主线程调用main方法。 同时再启动一个垃圾回收线程负责看护，回收垃圾。 最起码，现在的java程序中至少有两个线程并发， 一个是垃圾回收线程，一个是执行main方法的主线程。 3、进程和线程是什么关系？
Java 多线程编程基础(详细)
一夜星尘
11-03 3万+
Java多线程编程基础进程与线程多线程实现Thread类实现多线程Runnable接口实现多线程Callable接口实现多线程多线程运行状态多线程常用操作方法线程的命名和获取线程休眠线程中断线程强制执行线程让步线程优先级设定线程的同步和锁死线程同步处理线程死锁 进程与线程 进程与线程的基本认识 进程（Process）：进程是程序的一次动态执行过程，它经历了从代码加载、执行、到执行完毕的一个完整过程；同时也是并发执行的程序在执行过程中分配和管理资源的基本单位，竞争计算机系统资源的基本单位。 线程（Thread
java多线程（超详细）
zdl66的博客
08-14 10万+
进程就是正在运行中的程序（进程是驻留在内存中的）是系统执行资源分配和调度的独立单位每一进程都有属于自己的存储空间和系统资源注意：进程A和进程B的内存独立不共享。
Java多线程相关面试题整理
是袁同学呀
07-05 2501
个人闲暇时整理的Java并发编程相关问题，偏向于常见面试题总结，非系统的知识理解，不适合零基础。个人知识有限，如有遗漏欢迎补充。
Java多线程学习（吐血超详细总结）
热门推荐
Evankaka的专栏
03-14 42万+
本文主要讲了java中多线程的使用方法、线程同步、线程数据传递、线程状态及相应的一些线程函数用法、概述等。
Java多线程实战-CountDownLatch模拟压测实现
qq_35716689的博客
03-17 25万+
当多个线程需要协调和同步执行任务时，Java 中的 CountDownLatch（倒计时器）是一个常用的工具类。它可以帮助开发者实现线程之间的同步，确保某些线程在其他线程完成任务后再继续执行。牵着猫散步的鼠鼠。本文将介绍 CountDownLatch 的基本原理、用法以及示例代码，最后会使用CountDownLatch完成一个简单的压测实现。
Java零基础之多线程篇：多线程最佳实践
喵手的博客
08-01 1266
在计算机科学领域，多线程是一种重要的编程概念。它允许程序同时执行多个任务，提高了程序的并发性和响应性。对于Java开发者而言，了解和掌握多线程编程是非常重要的一项技能。本文将从零基础开始介绍Java多线程的概念和用法，帮助读者理解多线程的原理和实践技巧。我们将深入探讨多线程的最佳实践，包括源代码解析、应用场景案例、优缺点分析和具体的Java代码测试用例。本文将带领读者逐步学习Java多线程编程的基础知识和高级概念。我们将通过详细的源代码解析和实际应用场景案例，帮助读者理解多线程的内部工作原理和使用技巧。
Java基础——多线程详解！！！！
qq_52519008的博客
10-04 4867
就是进程中的一个独立控制单元，线程在控制着进程的执行。一个进程中至少有一个进程。多线程是多任务的一种特别的形式，但多线程使用了更小的资源开销。多线程能满足程序员编写高效率的程序来达到充分利用 CPU 的目的。注意：很多多线程是模拟出来的，真正的多线程是指有多个CPU，即多核，如服务器。如果是模拟出来的多线程，即在一个CPU的情况下，在同一个时间点，CPU只执行一个代码，因为切换得很快，所以就有同时执行的错觉。程序、进程和线程的大家可以通过百度搜索得知，在这里我就不多阐述。
Java多线程之基础篇(一).docx
04-16
Java多线程是Java语言中的一个重要特性，它允许程序同时执行多个不同的任务，从而提高程序的效率和响应性。在操作系统层面，实现并发最常见的方式是通过进程和线程。进程是具有独立内存空间的执行单元，而线程是进程...
Java多线程知识点总结
08-19
总之，掌握Java多线程的生命周期、创建、启动、同步以及线程池的使用是编写高效、稳定并发程序的基础。理解这些知识点对于解决并发编程中的问题，比如资源竞争、死锁、线程安全性等问题，至关重要。在实际开发中，...
Java多线程读取大文件
12-22
【Java多线程读取大文件】是一种优化的文件处理策略，特别适用于处理大型文本文件。在传统的单线程I/O操作中，读取大文件可能导致内存溢出（OOM），尤其是在尝试一次性加载整个文件到内存时。为了避免这个问题，我们...
基于SSM班级事务管理系统的设计
2401_87849773的博客
10-15 376
管理员账户功能包括：系统首页，个人中心，学生管理，班委管理，班会组织管理，健康档案管理，党员发展管理，党员培训管理，学生成绩管理。主要技术：Java,Spring,mybatis,mysql,jquery,html。班委账号功能包括：系统首页，学生管理，学生成绩管理，活动信息管理，班费通知管理。服务器：SpringBoot自带 apache tomcat。JDK版本：Java JDK1.8。数据库可视化工具： navicat。数据库版本： mysql5.7。开发系统：Windows。
Java安卓开发之Fragment开发（通俗易懂版）——第8章
一个脚本小子的博客
10-13 679
FragmentManager中的getSupportFragmentManager()方法不支持Activity，不论是旧版的FragmentManager还是新版的，因此我们要把继承Activity类改成继承AppCompatActivity类。
JavaWeb合集05-SpringBoot基础知识
最新发布
qq_57340195的博客
10-17 679
Autowrite ：自动装配，通过声明的数据类型来装配对应的bean对象。缺点，只能获取到一个相同类型的bean对象，如果有IOC容器里面有2个Bean对象，使用@Autowrite依赖注入就好报错。由于三层架构中，每一层都需要下次成来提供对应的方法，所有要new 下一次的对象，如果上一层的类名发送改变，那么上一层就需要修改对应的类名，如下。3、@Resource注解：通过它来代替@Autowrite注解，直接指定要注入的Bean对象，参数name的值就是要注入的Bean对象。
确保Spring Boot定时任务只执行一次方案
2301_76419561的博客
10-14 441
确保Spring Boot定时任务只执行一次有多种方法，你可以根据实际需求选择最适合的方法。如果你需要更复杂的任务调度或周期性执行，@Scheduled注解和接口是更合适的选择。而对于一次性的初始化任务或应用程序启动任务，注解和实现接口则更为简洁明了。
Java多线程：基础概念与应用
Java多线程是计算机编程中一个关键的概念，它允许程序在单个或多核CPU上执行多个并发任务，提高了系统的效率和响应性。本文将深入探讨多线程的相关概念，帮助理解程序、进程和线程之间的关系。 首先，理解这三个...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值