Java 多线程常用方法总结

内容导读

互联网集市收集整理的这篇技术教程文章主要介绍了Java 多线程常用方法总结，小编现在分享给大家，供广大互联网技能从业者学习和参考。文章包含11148字，纯文字阅读大概需要16分钟。

内容图文

Java多线程常用方法

方法一：Thread类的静态方法sleep()

作用：让当前线程停止执行，把CPU让给其他线程执行，但不会释放对象锁和监控的状态，也就是如果有Synchronized同步块，其他线程仍然不同访问共享数据。到了指定时间后线程又会自动恢复运行状态。
线程状态变化：运行 --》 等待 。 sleep时间到后线程自动由 等待 --》 就绪
注意：线程睡眠到期自动苏醒，并返回到可运行状态，不是运行状态。sleep()中指定的时间是线程不会运行的最短时间。因此，sleep()方法不能保证该线程睡眠到期后就开始执行

/**
 * @description: 线程休眠方法
 */
public class ThreadSleep implements Runnable {
  
    @Override
    public void run() {

        // 循环打印
        for (int i = 0 ; i < 100 ; i++ ){

            // 线程休眠
            try {
                Thread.sleep(i*10);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }

            // 打印内容
            System.out.println(Thread.currentThread().getId()+"======threadSleep======"+i);
        }
    }
}

public static void main(String[] args) {

        /**
         * 线程常用方法 sleep()
         * 作用是让当前线程停止执行，把cpu让给其他线程执行，但不会释放对象锁和监控的状态，到了指定时间后线程又会自动恢复运行状态。
         *
         * 注意：线程睡眠到期自动苏醒，并返回到可运行状态，不是运行状态。sleep()中指定的时间是线程不会运行的最短时间。
         * 因此，sleep()方法不能保证该线程睡眠到期后就开始执行
         */
        Runnable runnableThreadSleep = new ThreadSleep();
        Thread threadSleep = new Thread(runnableThreadSleep);
        threadSleep.start();

        Runnable runnableThreadSleep1 = new ThreadSleep();
        Thread threadSleep1 = new Thread(runnableThreadSleep1);
        threadSleep1.start();
}

方法二：Thread类的静态方法yield()

作用：暂停当前正在执行的线程对象（及放弃当前拥有的cup资源），并执行其他线程。yield()做的是让当前运行线程回到可运行状态，以允许具有相同优先级的其他线程获得运行机会。
线程状态变化：运行 --》 就绪
注意：使用yield()的目的是让相同优先级的线程之间能适当的轮转执行。但是，实际中无法保证yield()达到让步目的，因为让步的线程还有可能被线程调度程序再次选中。

/**
 * @description: 线程让行方法
 */
public class ThreadYield implements Runnable {

    @Override
    public void run() {

        // 循环打印
        for (int i = 0 ; i < 100 ; i++ ){

            // 线程让行
            Thread.yield();

            // 打印内容
            System.out.println(Thread.currentThread().getId()+"======threadYield======"+i);
        }
    }
}

public static void main(String[] args) {

        /**
         * 作用：暂停当前正在执行的线程对象（及放弃当前拥有的cup资源），并执行其他线程。yield()做的是让当前运行线程回到可运行状态，
         *      以允许具有相同优先级的其他线程获得运行机会。
         * 线程状态变化：运行 --》 就绪
         * 注意：使用yield()的目的是让相同优先级的线程之间能适当的轮转执行。
         *      但是，实际中无法保证yield()达到让步目的，因为让步的线程还有可能被线程调度程序再次选中。
         */
        Runnable runnableThreadYield = new ThreadYield();
        Thread threadYield = new Thread(runnableThreadYield);
        threadYield.start();

        Runnable runnableThreadYield1 = new ThreadYield();
        Thread threadYield1 = new Thread(runnableThreadYield1);
        threadYield1.start();
}

通过以上两个例子可以明显感觉到线程频繁切换会导致性能明显下降。

方法三：Thread类的join()方法

作用：主线程(生成子线程的线程)等待子线程（生成的线程）的终止。也就是在子线程调用了join()方法后面的代码，只有等到子线程结束了才能执行。
线程状态变化：
主线程：运行 --》 等待/超时等待(取决于调用的是join()还是join(long millis))  调用join方法的子线程执行完后会 等待/超时等待 --》 运行/阻塞(对象被锁)
子线程：就绪 --》 运行 --》 终止
注意：主线程不会释放已经持有的对象锁。

// 第一个测试实例 main方法为主线程
public static void main(String[] args) {

        // 线程一 子线程
        Thread thread01 = new Thread(new Runnable() {

            @Override
            public void run() {
                // 循环打印
                for (int i = 0 ; i < 100 ; i++ ){

                    // 打印内容
                    System.out.println(Thread.currentThread().getId()+"======thread01======"+i);
                }
            }
        });
        thread01.start();

        // 线程二 子线程
        Thread thread02 = new Thread(new Runnable() {

            @Override
            public void run() {
                // 循环打印
                for (int i = 0 ; i < 100 ; i++ ){

                    // 打印内容
                    System.out.println(Thread.currentThread().getId()+"======thread02======"+i);
                }
            }
        });
        thread02.start();
}

// 第二个测试实例 main方法为主线程
public static void main(String[] args) {

        // 线程一 子线程
        Thread thread01 = new Thread(new Runnable() {

            @Override
            public void run() {
                // 循环打印
                for (int i = 0 ; i < 100 ; i++ ){

                    // 打印内容
                    System.out.println(Thread.currentThread().getId()+"======thread01======"+i);
                }
            }
        });
        thread01.start();

        // 执行线程插入
        try {
            thread01.join();
        } catch (InterruptedException e) {
            e.printStackTrace();
        }

        // 线程二 子线程
        Thread thread02 = new Thread(new Runnable() {

            @Override
            public void run() {
                // 循环打印
                for (int i = 0 ; i < 100 ; i++ ){

                    // 打印内容
                    System.out.println(Thread.currentThread().getId()+"======thread02======"+i);
                }
            }
        });
        thread02.start();
}

// 通过上述两个测试实例，第一个实例输出内容线程一和线程二会交替输出，第二个实例输入内容会线程一全部输出完后线程二才会输出，由此可以证明线程一使用了join方法后
// 主线程会等到子线程（线程一）执行完后再继续执行后面的代码。

方法四：synchronized 关键字

作用：用来修饰一个方法或者一个代码块的时候，能够保证在同一时刻最多只有一个线程执行该段代码。
注意：
修饰实例方法，作用于当前实例加锁，进入同步代码前要获得当前实例的锁
修饰静态方法，作用于当前类对象加锁，进入同步代码前要获得当前类对象的锁
修饰代码块，指定加锁对象，对给定对象加锁，进入同步代码库前要获得给定对象的锁。

public class SynchronizedObject {

    private static String info = "info";

    /**
     * 同步代码块
     * @param name
     */
    public void getName(String name){

        // 此时锁的是括号内的对象
        synchronized (name){
            System.out.println("getName name = " + name);
        }
    }

    /**
     * 同步方法
     * 此时锁的是当前实例的对象。
     * @param name
     */
    public synchronized void setName(String name){
        System.out.println("setName name = " + name);
    }

    /**
     * 静态同步方法
     */
    public static synchronized void staticSynchronized(){
        System.out.println("class info = " + info);
    }

}

方法五：Object类的wait()方法

作用：让当前线程进入等待状态。
线程状态：运行 --》 等待/超时等待
注意：
1、当前线程必须是此对象的监视器所有者，否则还是会发生 IllegalMonitorStateException 异常。所以wait方法和synchronized 关键字组合使用
2、如果当前线程在等待之前或在等待时被任何线程中断，则会抛出 InterruptedException 异常。

/**
  * 简单的人员对象
  */
private static Person person = new Person();

public static void main(String[] args) {

    // 线程一
    Thread thread01 = new Thread(new Runnable() {

        @Override
        public void run() {

            // 获取对象锁
            synchronized (person){

                // 设置名称
                person.setName("Engraver");

                try {

                    // 释放 person 对象锁 并进入等待其他获取该对象锁的线程唤醒
                    person.wait();

                    // 使线程休眠
                    Thread.sleep(200);

                    System.out.println("thread01 person name " + person.getName());
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }

        }
    });
    thread01.start();

    // 线程二
    Thread thread02 = new Thread(new Runnable() {

        @Override
        public void run() {

            synchronized (person){

                System.out.println("thread02 set person name before" + person.getName());
                person.setName("甜甜");
                System.out.println("thread02 set person name after" + person.getName());

                // 唤醒当前对象上的等待线程
                person.notify();
            }

        }
    });
    thread02.start();
}

方法六：Object类的notify()方法

作用：唤醒等待该锁的其中一个线程。
线程状态：运行 --》 等待/结束
注意：notify只会随机选取一个处于等待池中的线程进入锁池去竞争获取锁的机会

/**
  * 简单的人员对象
  */
private static Person person = new Person();

public static void main(String[] args) {

    // 线程一
    Thread thread01 = new Thread(new Runnable() {

        @Override
        public void run() {

            // 获取对象锁
            synchronized (person){

                // 设置名称
                person.setName("Engraver");

                try {

                    // 释放 person 对象锁 并进入等待其他获取该对象锁的线程唤醒
                    person.wait();

                    // 使线程休眠
                    Thread.sleep(200);

                    System.out.println("thread01 person name " + person.getName());
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }

        }
    });
    thread01.start();

    // 线程二
    Thread thread02 = new Thread(new Runnable() {

        @Override
        public void run() {

            synchronized (person){

                System.out.println("thread02 set person name before" + person.getName());
                person.setName("甜甜");
                System.out.println("thread02 set person name after" + person.getName());

                // 唤醒当前对象上的等待线程
                person.notify();
            }

        }
    });
    thread02.start();
}

方法七：Object类的notifyAll()方法

作用：唤醒等待该锁的所有线程。
线程状态：运行 --》 等待/结束
注意：notify只会随机选取一个处于等待池中的线程进入锁池去竞争获取锁的机会。

/**
 * 简单的人员对象
 */
private static Person person = new Person();

public static void main(String[] args) {

    // 线程一
    Thread thread01 = new Thread(new Runnable() {

        @Override
        public void run() {

            // 获取对象锁
            synchronized (person){

                // 设置名称
                person.setName("Engraver");

                try {

                    // 释放 person 对象锁 并进入等待其他获取该对象锁的线程唤醒
                    person.wait();

                    // 使线程休眠
                    Thread.sleep(200);

                    System.out.println("thread01 person name " + person.getName());
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }

        }
    });
    thread01.start();

    // 线程二
    Thread thread02 = new Thread(new Runnable() {

        @Override
        public void run() {

            synchronized (person){

                System.out.println("thread02 set person name before" + person.getName());
                person.setName("甜甜");
                System.out.println("thread02 set person name after" + person.getName());

                // 释放 person 对象锁 并进入等待其他获取该对象锁的线程唤醒
                try {
                    person.wait();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }

        }
    });
    thread02.start();

    // 线程三
    Thread thread03 = new Thread(new Runnable() {

        @Override
        public void run() {

            synchronized (person){

                System.out.println("thread03 set person name before" + person.getName());
                person.setName("小橘子");
                System.out.println("thread03 set person name after" + person.getName());

                // 唤醒当前对象上所有等待的线程
                person.notifyAll();
            }

        }
    });
    thread03.start();
}

notify() 和 notifyAll() 方法的区别

锁池
假设线程A已经拥有了某个对象(不是类)的锁，而其它线程B、C想要调用这个对象的某个synchronized方法(或者代码块), 由于B、C线程在进入对象的synchronized方法(或者块)之前必须先获得该对象锁的拥有权，而恰巧该对象的锁目前正被线程A所占用，此时B、C线程就会被阻塞，进入一个地方去等待锁的释放，这个地方便是该对象的锁池

等待池
假设线程A调用了某个对象的wait()方法，线程A就会释放该对象的锁，同时线程A就进入到了该对象的等待池中，进入到等待池中的线程不会去竞争该对象的锁。

notifyAll会让所有处于等待池的线程全部进入锁池去竞争获取锁的机会
notify只会随机选取一个处于等待池中的线程进入锁池去竞争获取锁的机会

方法八：Thread类静态方法interrupt()

作用：中断线程。将会设置该线程的中断状态位，即设置为true，中断的结果线程是死亡、还是等待新的任务或是继续运行至下一步，就取决于这个程序本身。
线程状态：无状态改变，改变的是线程的一个标记。
注意：
1、只是改变中断状态，不会中断一个正在运行的线程。
2、如果线程处于被阻塞状态（例如处于sleep, wait, join 等状态），那么线程将立即退出被阻塞状态，并抛出一个InterruptedException异常。仅此而已。
3、如果线程处于正常活动状态，那么会将该线程的中断标志设置为 true，仅此而已。被设置中断标志的线程将继续正常运行，不受影响。

public static void main(String[] args) {

    String name = "Engraver";

    // 线程一
    Thread thread01 = new Thread(new Runnable() {

        @Override
        public void run() {

            // 获取对象锁
            synchronized (name){

                // 进入等待
                try{
                    name.wait();
                }catch (InterruptedException e){
                    System.out.println(" name.wait() InterruptedException");
                }

                // 判断是否中断 可以看到当条件为true时线程并未终止而是继续执行输出语句
                while (Thread.interrupted()){
                    System.out.println("thread01 interrupted true");
                }
            }

        }
    });
    thread01.start();

    // 线程二
    Thread thread02 = new Thread(new Runnable() {

        @Override
        public void run() {

            // 获取对象锁
            synchronized (name){

                // 唤醒等待name对象的线程
                name.notify();

                /**
                     * 执行线程1中断
                     * name.notify();
                     * thread01.interrupt();
                     * 先释放name锁后中断会正常执行thread01线程后面的代码
                     * thread01.interrupt();
                     * name.notify();
                     * 先中断后执行释放name锁thread01会抛出异常后面语句不会执行
                     */
                thread01.interrupt();
                
                System.out.println("测试线程是否立即中断");
            }

        }
    });
    thread02.start();

}

内容总结

以上是互联网集市为您收集整理的Java 多线程常用方法总结全部内容，希望文章能够帮你解决Java 多线程常用方法总结所遇到的程序开发问题。如果觉得互联网集市技术教程内容还不错，欢迎将互联网集市网站推荐给程序员好友。

内容备注

版权声明：本文内容由互联网用户自发贡献，该文观点与技术仅代表作者本人。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如发现本站有涉嫌侵权/违法违规的内容，请发送邮件至 gblab@vip.qq.com 举报，一经查实，本站将立刻删除。

内容手机端

扫描二维码推送至手机访问。

本文链接：https://qyyshop.com/info/589131.html

来源：【匿名】

【上一篇】Java基础练习——读心术（扑克牌魔术——21张扑克牌）--代码简化版【下一篇】JAVA/JSP学习系列之五

更多 ►

【Java 多线程常用方法总结】教程文章相关的互联网学习教程文章

用iframe、弹出子页面刷新父页面iframeJs代码 <script language=JavaScript> parent.location.reload(); </script> 弹出子页面Js代码 <script language=JavaScript> window.opener.location.reload(); </script> 子窗口刷新父窗口Js代码 <script language=JavaScript> self.opener.location.reload(); </script> 刷新以open()方法打开的窗口Js代码 <script language=JavaScript> window.opener.loca...

Javascript操作元素属性方法总结

?1234567891011121314151617181920<!DOCTYPE html><html xmlns="http://www.w3.org/1999/xhtml"><head><meta http-equiv="Content-Type"content="text/html; charset=utf-8"/> <title></title></head><body> <!-- 元素属性的操作第一种：oDiv.style.display="none"; 第二种：oDiv.style["display"]="none"; 第三种：Dom方式 Dom方式操作元素的属性获取：getAttribute(名称);//...

Java调用IDL方法总结【图】

650) this.width=650;" src="/upload/getfiles/default/2022/11/14/20221114040456416.jpg" title="1.jpg" />650) this.width=650;" src="/upload/getfiles/default/2022/11/14/20221114040456851.jpg" title="2.jpg" />650) this.width=650;" src="/upload/getfiles/default/2022/11/14/20221114040457279.jpg" title="3.jpg" />650) this.width=650;" src="/upload/getfiles/default/2022/11/14/20221114040457702.jpg" title=...

java基础知识1--String常用方法总结【代码】

主要涉及String常用的方法。package collection;import java.lang.reflect.Array; import java.util.Arrays;/*** Created by wyy on 2017/2/16.*/publicclass StringTest {publicstaticvoid main(String[] args) {//String的用法//输出第3个字符String str="WATERMELON";String st="lalaland";System.out.println(str.charAt(2));//将字符数组转化为字符串char[] ch={‘a‘,‘b‘,‘c‘,‘d‘};String c=new String(ch);//abcdStri...

java 实现线程的其中两种方法总结

方法一：Runnable接口：模式为静态代理，代理方为Thread（方便数据共享）classl mary implements Runnable{//线程体public void run(){}} 使用 new Thread(new mary()).start();启动线程方法二：继承Threadclass mary extends Thread{ public void run（）{/*线程体*/}}使用new mary().start();启动线程原文：http://www.cnblogs.com/liangjiehai/p/4734723.html

Apache Hadoop 运行分布式程序方法总结（Streaming方式与原生JAVA接口）【代码】【图】

1. Hadoop Streaming方式运行程序Hadoop Streaming可以运行除JAVA语言以外，其它的语言编写的程序。其启动脚本示例如下： 1 #!/bin/sh 2 3# 参数合法性判断4 5if [ $# != 7 ]; then 6echo"./bin/avp_platform_startup.sh [USER_NAME] [INPUT_PAT] [OUTPUT_PAT] [MAP_TASKS] [REDUCE_TASKS] [CLASS_ID] [CODE_TYPE]" 7 exit8fi 910# GLOBAL VARS 11 USER_NAME=$112 INPUT_PAT=$213 OUTPUT_PAT=$314 MAP_TASKS=$415 REDUCE_TASK...

Java中获取资源文件的方法总结【代码】【图】

这里总结3中方法获取资源文件的ServletContextClassClassLoader文件的位置 1. ServletContextpublic void doGet(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {PrintWriter pw = response.getWriter();ServletContext context = this.getServletContext();/*** 获取不同路径下的资源文件* servletContext是相对于项目的根目录的，这里为WebContent*/InputStream inputA = co...

Java集合Collection遍历方法总结【代码】

集合类的通用遍历方式, 用迭代器迭代:Iterator it = list.iterator();while(it.hasNext()) {　　Object obj = it.next();} Map遍历方式： 1、通过获取所有的key按照key来遍历//Set<Integer> set = map.keySet(); //得到所有key的集合for (Integer in : map.keySet()) {String str = map.get(in);//得到每个key多对用value的值 } 2、通过Map.entrySet使用iterator遍历key和valueIterator<Map.Entry<Integer, String>> it = map.entr...

20110826 Java学习方法总结

学习JavaEE已经有一段时间了，自以为对JavaEE也是有一点地认识和理解的。如果有菜鸟也想学习JavaEE的话，那么，下面推荐一下我的学习进阶步骤（仅代表我个人）:①先学JAVA的基本语法。如Logic Java、Java oop 等，精通面向对象的思想：封装、继承和多态，以及后面学的接口。 ( 其中封装和继承稍微简单一点，多态比较难一点；但能不能理解好多态，又是能不能理解面向对象思想的重要一步，而接口，学习起来并不难，难就难在如何运用...

java解析json方法总结

工具包org.json.jar，是一个轻量级的，JAVA下的json构造和解析工具包，它还包含JSON与XML, HTTP headers, Cookies, CDL的转换。这里推荐使用：阿里巴巴FastJson是一个Json处理工具包，包括“序列化”和“反序列化”两部分，它具备如下特征：速度最快，测试表明，fastjson具有极快的性能，超越任其他的Java Json parser。包括自称最快的JackJson；功能强大，完全支持Java Bean、集合、Map、日期、Enum，支持范型，支持自省；无依赖...

JavaScrip数组删除特定元素的几种方法总结

从js数组中删除指定元素是我们每个人都遇到的问题，网上这方面的资料也很多，但有的时间过于久远，有的内容不够全面，所以自己来整理下，这篇文章主要给大家总结介绍了关于JavaScrip数组删除特定元素的多种方法，需要的朋友可以参考下。前言可能一说到删除数组特定元素你估计不止一种方法可以实现，那么下面且来看看我总结的这几种方法，可能会对你有所帮助！话不多说了，来一起看看详细的介绍吧。源数组伪删除什么是伪删除呢? 就是...

Java File类的常用方法总结

Java File类的功能非常强大，利用Java基本上可以对文件进行所有的操作。本文将对Java File文件操作类进行详细地分析，并将File类中的常用方法进行简单介绍，有需要的Java开发者可以看一下。构造函数代码如下: public class FileDemo { public static void main(String[] args){ //构造函数File(String pathname) File f1 =new File("c:\\abc\\1.txt"); //File(String parent,String child) ...

atitit.判断时间重叠方法总结javac++c#.netjsphp

atitit.判断时间重叠方法总结 java c++ c#.net js php 1. 判断时间重叠具体流程思路 1 2. 重叠算法实际上就是日期集合跟个时间集合的的交集(乘法算法) 1 3. 代码--- 1 4. 最终生成的sql 3 5. 参考 5 1. 判断时间重叠具体流程思路先判断日期重叠，在判断时atitit.判断时间重叠方法总结 java c++ c#.net js php1. 判断时间重叠具体流程思路 1 2. 重叠算法实际上就是日期集合跟个时间集合的的交集(乘法算法) 1 3. 代码--- 1 4. 最终...