多线程---中，创建方法，终端，属性，线程安全（重点），

于 2021-09-05 13:34:02 发布
阅读量128 收藏
点赞数
分类专栏： JAVA 文章标签： java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_45417628/article/details/120113898
版权

多 线 程

1.创建线程的方法

  • 1.继承自Thread，重写run方法，
  • 2.实现runnable接口，把runnable接口的实例赋值给Thread
import java.util.TreeMap;

/**
 * User:yang
 */
class MyTask implements Runnable{
    @Override
    public void run() {
        while (true){
            System.out.println("hello");
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }
}

public class ThreadDemo2 {
    public static void main(String[] args) {
        Runnable myTask=new MyTask();
        Thread t=new Thread(myTask);
        t.start();
    }
}
  • 3.匿名内部类（thread）
Thread t2=new Thread(){
            @Override
            public void run() {
                long b=0;
                for (long i = 0; i <count ; i++) {
                    b++;
                }
            }
        };
  • 4.匿名内部类（runnable）
    public static void main(String[] args) {
        Thread t=new Thread(new Runnable() {
            @Override
            public void run() {
                System.out.println("hello");
            }
        });
        t.start();
    }
  • 5.使用lambda表达式创建线程
   public static void main(String[] args) {
        Thread t=new Thread(()->{
            System.out.println("hello");
        });
        t.start();
    }

2.线程属性

  • 线程设置名称setName()
/**
 * User:yang
 */
public class ThreadDemo3 {
    public static void main(String[] args) {
        Thread t1=new Thread(){
            @Override
            public void run() {
                while (true){
                    System.out.println("hello");
                    try {
                        Thread.sleep(1000);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }
            }
        };
        t1.setName("t1");
        t1.start();

        Thread t2=new Thread(){
            @Override
            public void run() {
                while (true){
                    System.out.println("hello");
                    try {
                        Thread.sleep(1000);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }
            }
        };
        t2.setName("t2");
        t2.start();
    }
}
  • 打印各种属性
/**
 * User:yang
 */
public class ThreadDemo4 {
    public static void main(String[] args) {
        Thread t = new Thread(() -> {
            Thread.currentThread().setName("1111");
            for (int i = 0; i < 10; i++) {
                System.out.println(Thread.currentThread().getName() + "正在运行中");
                try {
                    Thread.sleep(1000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
            System.out.println(Thread.currentThread().getName() + "运行完毕，即将销毁");

        });
        System.out.println(t.getId());
        System.out.println(t.getName());
        System.out.println(t.getState());
        System.out.println(t.isDaemon());
        System.out.println(t.getPriority());
        System.out.println(t.isAlive());
        System.out.println(t.isInterrupted());
        t.start();
        System.out.println("线程创建之后");System.out.println(t.getId());
        System.out.println(t.getName());
        System.out.println(t.getState());
        System.out.println(t.isDaemon());
        System.out.println(t.getPriority());
        System.out.println(t.isAlive());
        System.out.println(t.isInterrupted());
    }
}

3.Start方法

  • 线程对象被创建出来并不意味着线程就开始运行了,需要Start

4.中断一个线程

  • 1.通过共享的标记
/**
 * User:yang
 */
public class ThreadDemo6 {
    static boolean isRunning = true;

    public static void main(String[] args) throws InterruptedException {
        Thread t = new Thread() {
            @Override
            public void run() {
                while (isRunning) {
                    System.out.println("hello");
                    try {
                        Thread.sleep(1000);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }
            }
        };
        t.start();
        Thread.sleep(5 * 1000);
        isRunning = false;
    }

}
  • 2.调用 interrupt(）方法
/**
 * User:yang
 */
//调用 interrupt(）方法终止
public class ThreadDemo7 {
    public static void main(String[] args) throws InterruptedException {
        Thread t=new Thread(){
            @Override
            public void run() {
                while (!Thread.currentThread().isInterrupted()){
                    System.out.println("hello");
                    try {
                        Thread.sleep(1000);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                        break;
                    }
                }
            }
        };
        t.start();
        Thread.sleep(5*1000);
        System.out.println("线程终止");
        t.interrupt();
    }
}

5.等待线程机制

  • 不是有顺序的开始，而是能确认结束的顺序。
  • join 方法
/**
 * User:yang
 */
public class ThreadDemo8 {
    public static void main(String[] args) throws InterruptedException {
        Thread t=new Thread(){
            @Override
            public void run() {
                int i=0;
                while (i<5){
                    System.out.println("jelol");
                    i++;
                    try {
                        Thread.sleep(1000);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }
            }
        };t.start();
        //执行到join就会阻塞等待，等到t执行完毕，join才会往下执行
        Thread.sleep(6000);
        System.out.println("即将调用join");
        t.join();
        System.out.println("t执行完毕");
    }
}

6. 获取当前线程引用

/**
 * User:yang
 */
public class ThreadDemo9 {
    public static void main(String[] args) {
        Thread t1 = new Thread() {
            @Override
            public void run() {
                System.out.println(Thread.currentThread().getId());
                System.out.println(this.getId());
            }
        };
        t1.start();
        Thread t2 = new Thread() {
            @Override
            public void run() {
                System.out.println(Thread.currentThread().getId());
                System.out.println(this.getId());
            }
        };
        t2.start();

        System.out.println(Thread.currentThread().getId());

    }
}

7. 线程休眠

8.线程的状态

  • NEW

  • RUNNABLE

  • BLOCKED

  • WAITING

  • TIMED_WAITING

  • TERMINATED

/**
 * User:yang
 */
public class ThreadDemo10 {
    public static void main(String[] args) {
        Thread t=new Thread(new Runnable() {
            @Override
            public void run() {
                for (int i = 0; i <1000_0000 ; i++) {

                }
            }
        });
        System.out.println("before"+t.getState());
        t.start();
        while (t.isAlive()){
            System.out.println("during"+t.getState());

        }
        System.out.println("end"+t.getState());

    }
}


/**
 * User:yang
 */
public class ThreadDemo11 {
    public static void main(String[] args) throws InterruptedException {
        Thread t=new Thread(new Runnable() {
            @Override
            public void run() {
               while (true){
                   try {
                       Thread.sleep(1000);
                   } catch (InterruptedException e) {
                       e.printStackTrace();
                   }
               }
            }
        });

        t.start();
        while (true){
            System.out.println(" "+t.getState());
            Thread.sleep(1000);

        }

    }
}

9.线程安全

  • 不安全的原因：
  • 1.抢占式执行。（万恶之源）
  • 2.多个线程修改同一个变量
  • 3.修改操作不是原子的
  • 4.内存可见性（编译器优化）
  • 5.指令重排序（编译器优化）

9.1两个线程分别增加5000，实际结果不是10000

/**
 * User:yang
 */
class Counter {
    public static int count=0;


    public static void increase(){
        count++;

    }
}
public class ThreadDemo12 {
    public static void main(String[] args) throws InterruptedException {
        Counter counter=new Counter();

        Thread t1=new Thread(){
            @Override
            public void run() {
                for (int i = 0; i < 50000; i++) {
                    counter.increase();
                }
            }
        };
        Thread t2=new Thread(){
            @Override
            public void run() {
                for (int i = 0; i < 50000; i++) {
                    counter.increase();
                }
            }
        };
        t1.start();
        t2.start();
        t1.join();
        t2.join();
        System.out.println(counter.count);
    }
}

10.线程安全的解决办法（synchronize）

10.1synchronize（关键字） 监视器锁（atm取钱）

  • 功能：保证操作的原子性，禁止指令重排序，保证内存可见性

10.2修饰一个方法

相当于加了LOCK，UNLOCK


  synchronized  public   void increase(){
        count++;

    }

10.3修饰一个代码块

   public void increase() {
        synchronized (this) {
            count++;
        }
    }

Thread t2 = new Thread() {
            @Override
            public void run() {
                for (int i = 0; i < 50000; i++) {
                    synchronized(counter){
                        counter.increase();
                    }
                }
            }
        };

10.4嵌套加锁

  • synchronized内部进行了特殊处理，可重入锁。
  • 在这里插入图片描述
/**
 * User:yang
 */
class Counter {
    public static int count = 0;
//      public   void increase(){
//        count++;
//
//    }

    synchronized void increase() {
        count++;

    }

//    public void increase() {
//        synchronized (this) {
//            count++;
//        }
//    }
}

public class ThreadDemo12 {
    public static void main(String[] args) throws InterruptedException {
        Counter counter = new Counter();

        Thread t1 = new Thread() {
            @Override
            public void run() {
                for (int i = 0; i < 50000; i++) {
                    synchronized (counter) {
                        counter.increase();
                    }
                }
            }
        };
        Thread t2 = new Thread() {
            @Override
            public void run() {
                for (int i = 0; i < 50000; i++) {
                    synchronized (counter) {
                        counter.increase();
                    }
                }
            }
        };
        t1.start();
        t2.start();
        t1.join();
        t2.join();
        System.out.println(counter.count);
    }
}

11.volatile（比synchronized更轻量）

  • 效果：辅助保证线程安全
  • 作用：禁止指令重排序，保证内存可见性，但是不保证原子性
  • 主要用于读写同一个变量的时候
  • 当两个线程都要写的时候，volatile无能为力，要用synchronized
import java.util.Scanner;

/**
 * User:yang
 */
public class ThreadDemo13 {
   static class Counter{

   volatile      public int  flag=0;
    }

    public static void main(String[] args) {
        Counter counter=new Counter();
        Thread t1=new Thread(){
            @Override
            public void run() {
                while (counter.flag==0){

                }
                System.out.println("线程1  循环结束");
            }
        };t1.start();
        Thread t2=new Thread(){
            @Override
            public void run() {
                Scanner scanner=new Scanner(System.in);
                System.out.println("please input an int ");
                counter.flag=scanner.nextInt();
            }
        };t2.start();
    }
}

12.wait/notify

  • wait，notify都必须在synchronized里面使用

12.1wait

  • 1.释放锁
  • 2.等待其他线程的通知
  • 3.等通知来了之后，重新尝试获取锁
  • 必须在synchronized里面使用

12.2notify

  • 作用：通知某个线程从wait醒来
  • 必须在synchronized里面使用
  • 调用notify方法之后，代码不会立即释放锁，而是执行完synchronized之后才释放锁。同时等待的线程们就尝试重新竞争这个锁
/**
 * User:yang
 */
//wait   notify   用法
public class ThreadDemo15 {
    static public Object locker = new Object();

    //用来等待的线程
    static class WaitTask implements Runnable {
        @Override
        public void run() {
            synchronized (locker) {
                while (true) {
                    System.out.println("wait 开始");
                    try {
                        locker.wait();
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                    System.out.println("wait 结束");
                }
            }
        }
    }

    //用来通知的线程
    static class NotifyTask implements Runnable {
        @Override
        public void run() {

            synchronized (locker) {
                System.out.println("notify 开始");
                locker.notify();
                System.out.println("notify 结束");
            }
        }
    }

    public static void main(String[] args) throws InterruptedException {
        Thread t1 = new Thread(new WaitTask());
        Thread t2 = new Thread(new NotifyTask());
        t1.start();
        Thread.sleep(3000);
        t2.start();
    }
}

12.3notifyAll

  • 将所有waiting变成就绪，然后只有一个竞争到，竞争失败的就会blocked

13.注意

  • 调用wait/notify/加锁synchronized都是针对同一个对象进行

14.JMM

Java Memory Model Java内存模型

杨儿的聪明难以想象
关注
专栏目录
[Java核心基础】Java多线程编程详细入门教程
weixin_54707168的博客
02-27 298
[Java核心基础】Java多线程编程详细入门教程
【操作系统原理】第二章-进程和线程
qq_41669298的博客
02-20 676
进程和线程 进程 什么是进程   在操作系统中，操作系统需要对各种资源进行管理，大概可以分为以下几类：内存，文件，磁盘，进程。所谓进程就是操作系统有序管理应用程序的执行的方式，来保证以下几点：   1、所有资源对多个应用程序是可用的。   2、物理处理器在多个应用程序中切换，保证所有程序都在执行中。   3、处理器和I/O设备都能得到充分的利用。   因此所有现代操作系统都依赖于一个模型，在该模型...
java笔记线程方式1线程终端与停止
weixin_30765475的博客
02-09 79
public final void stop():让线程停止，过时了，但是还可以使用。public void interrupt():中断线程。 把线程的状态终止，并抛出一个InterruptedException。 1 public class ThreadStopDemo { 2 public static void main(String[] args) { ...
线程的常用方法介绍
小仙女的博客
09-18 7387
start()与run()       start() 启动线程并执行相应的run()方法       run() 子线程要执行的代码放入run()方法 我们会发现，调用start()方法才是 启动一个新的线程。调用run()方法只是主线程调用了一个类的一个普通方法。 getName()和setName()  getName() 获取此线程的名字  setName() 设置此线程的名字...
java终端线程_java多线程-中断线程
weixin_34502439的博客
02-17 229
大纲：java线程的中断原则中断相关方法中断实例一、java线程中断原则java中断是一种协作机制，每一个线程的中断都由线程自己处理，其他线程只是给要中断的线程一个中断标志。二、相关方法1.把线程对象的中断标志置为truepublic void interrupt()2.判断线程对象的中断标志public boolean isInterrupted()3.判断当前的线程中断标志，并清除该标志(注意...
创建线程时安全传递参数例子
fengkuangfj的专栏
12-30 578
虽然传参不是由分配者去释放的，但是这样做既能保证参数传递的安全性，又能不影响创建者线程的正常工作typedef struct _MY_STRUCT { ULONG ul1; ULONG ul2; ULONG ul3; } MY_STRUCT, *PMY_STRUCT, *LPMY_STRUCT; DWORD WINAPI ThreadProc( _In_ LPVOID lpPara
【多线程】——深入理解线程中断方式（interrupt）
漫漫长途，终有回转；余味苦涩，终有回甘
06-06 1万+
    最近在系统回顾多线程这一部分的内容，对线程中断方式这一部分相比之前有了不同的认识。整理一下，如有理解偏颇之处，还请各位大神不惜赐教。    在看高洪岩《Java多线程编程核心技术》的时候里面讲了很多种停止线程方式，其实仔细回想起来停止线程并没有那么复杂。总体整理下来就三种方式！1、正常退出;2、stop暴力停止（不再推荐使用）；3、异常法;1、正常退出当线程中run()或者call()按照...
基于PyQt5的图形界面程序设计 以冒泡排序为例 - Python多线程
海洋饼干叔叔
07-30 1538
本书同名免费MOOC《Python编程基础及应用》在哔哩哔哩（B站）热播，作者带着你学。 版权声明：本文内容引用自作者的图书《Python编程基础及应用》（高等教育出版社)。本文可以在互联网上转载传播，但必须包含文中的版权声明；本文不可以以纸质出版为目的进行摘抄或改编。 附录A.3. 实践 - 冒泡及轻者上浮 Python自带有标准GUI-图形用户界面工具包Tkinter。但Tkinter的功能相对比较简单，界面也不够漂亮，对于规模大一点的GUI应用略显不足。在当前的Python生态圈，如果读者需要一
面试百度和美团，竟然问我多线程安全问题，正好撞在我知识点上
Emmliy的博客
07-08 146
解决多线程安全问题-无非两个方法synchronized和lock 具体原理以及如何 获取锁AQS算法 本篇文章主要讲了lock的原理 就是AQS算法，还有个姊妹篇 讲解synchronized的实现原理 也是阿里经常问的， 一定要看后面的文章，先说结论： 非公平锁tryAcquire的流程是：检查state字段，若为0，表示锁未被占用，那么尝试占用，若不为0，检查当前锁是否被自己占用，若被自己占用，则更新state字段，表示重入锁的次数。如果以上两点都没有成功，则获取锁失败，返回false。 前几天去百度
JUC并发多线程进阶
早上真起不来的博客
06-09 340
笔记整理来源 B站UP主狂神说Java https://space.bilibili.com/95256449/ JUC并发多线程进阶 1、什么是JUC 源码+官方文档 JUC是 java util concurrent 面试高频问JUC~！ java.util 是Java的一个工具包~ 业务：不会通过普通的线程代码 Thread 来实现 Runnable： 没有返回值、效率相比于Callable 相对较低！ 2、线程和进程 进程：一个程序，QQ.exe Music.exe；数据+代码+pcb 一个进程可
终止线程的三种方法
热门推荐
涑飏的专栏
07-17 9万+
有三种方法可以使终止线程。    1.  使用退出标志，使线程正常退出，也就是当run方法完成后线程终止。    2.  使用stop方法强行终止线程（这个方法不推荐使用，因为stop和suspend、resume一样，也可能发生不可预料的结果）。    3.  使用interr
java 用户线程如何修改界面内容_如何中断JAVA线程
weixin_39687422的博客
02-16 129
一些轻率的家伙可能被另一种方法Thread.interrupt所迷惑。尽管，其名称似乎在暗示着什么，然而，这种方法并不会中断一个正在运行的线程(待会将进一步说明)，正如ListingA中描述的那样。它创建了一个线程，并且试图使用Thread.interrupt方法停止该线程。Thread.sleep()方法的调用，为线程的初始化和中止提供了充裕的时间。线程本身并不参与任何有用的操作。class...
如何停止/中断一个运行中的线程
ITMuch的专栏
06-09 952
点击上方IT牧场，选择置顶或者星标技术干货每日送达！# 面试题：如何正确地停止/中断一个运行中的线程哪些情况下线程会停止如何处理不可中断的阻塞# 核心思想使用interrupt()...
Thread的中断机制(interrupt)
weixin_30505225的博客
02-24 2501
先看收集了别人的文章，全面的了解下java的中断： 中断线程 线程的thread.interrupt()方法是中断线程，将会设置该线程的中断状态位，即设置为true，中断的结果线程是死亡、还是等待新的任务或是继续运行至下一步，就取决于这个程序本身。线程会不时地检测这个中断标示位，以判断线程是否应该被中断（中断标示值是否为true）。它并不像stop方法那样会中断一个正在运行的线程。 判断线程...
线程的停止和中断
hello world
04-22 3085
线程停止有四种种情况： 1.run运行结束 2.异常退出 3.stop强制中止，这个不推荐使用，存在风险，比如说扫尾清理工作未完成，关闭资源未完成 就退出了。 4.interrupt方法中断线程， 需要主动编码配合，写中断逻辑，但是可控。 调用interrupt（）方法只是打了个退出标志，并非真正的退出，退出逻辑需要自己写。 package ThreadCheat1.interrupt; /**...
理解Java线程的中断
dawuafang
06-18 159
一个线程在未正常结束之前, 被强制终止是很危险的事情. 因为它可能带来完全预料不到的严重后果. 所以你看到Thread.suspend, Thread.stop等方法都被Deprecated了. 那么不能直接把一个线程搞挂掉, 但有时候又有必要让一个线程死掉, 或者让它结束某种等待的状态 该怎么办呢? 优雅的方法就是, 给那个线程一个中断信号, 让它自己决定该怎么办. 比如说, 在某个子线程中为...
线程中断机制
爱琴孩的博客
08-21 1247
前言 之前我们捋清楚了线程中的sleep(),wait(),join()等方法，这里我们再来学习下java中的线程中断机制。中断是一种协作机制。当一个线程中断另一个线程时，被中断的线程不一定要立即停止正在做的事情。相反，中断是礼貌地请求另一个线程在它愿意并且方便的时候停止它正在做的事情。有些方法，例如 Thread.sleep()，很认真地对待这样的请求，但每个方法不是一定要对中断作出响应。对于...
线程中断
写写代码
02-20 2875
线程中断就是处于运行状态的线程被强制打断。线程中断总体来说有三种方法：正常退出、stop暴力停止、interrupt异常停止。其中使用stop()方法是不安全的，可能导致数据不同步或者资源无法回收，目前stop()方法已经被标注为作废方法。一般使用interrupt停止线程，这里有几个与之相关的方法： public void interrupt() {} // 中断线程 public boo...
Java线程中断机制-如何中断线程
weixin_33932129的博客
11-10 903
介绍： 对于线程一共分为五个状态：新建状态，就绪状态，阻塞状态，运行状态，死亡状态，有时候把阻塞状态又分为同步阻塞和等待阻塞。 有时想让主线程启动的一个子线程结束运行，我们就需要让这个子线程中断，不再继续执行。线程是有中断机制的，我们可以对每个线程进行中断标记，注意只是标记，中断与否还是虚拟机自己的事情，虚拟机自己家的事情，我们也就说说，不能实际操作控制他家。java中的Thread类是...
Cocos2d-x 3.0：使用多线程异步加载资源提升性能
例如，你可以在C++中创建工作线程，然后通过JNI调用Java层的方法，利用Java的异步机制来处理网络请求或文件读写，最后通过JNI回调将结果传回C++。 总结来说，Cocos2d-x 3.0中实现多线程异步加载资源的关键在于合理...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值