Java 线程

最新推荐文章于 2021-08-15 14:11:14 发布
最新推荐文章于 2021-08-15 14:11:14 发布
阅读量180 收藏
点赞数
CC 4.0 BY-SA版权
分类专栏： Java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/a1781842634/article/details/117153900

创建线程的两种方式

在Java中线程的使用有两种方法：

  1. 继承Thread类，重写run方法
  2. 实现Runnable接口，重写run方法在这里插入图片描述
    当main线程启动一个子线程 Thread-0, 主线程不会阻塞, 会继续执行

关于start()方法和run()方法

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

        //创建Cat对象，可以当做线程使用
        Cat cat = new Cat();

        /*
            (1)
            public synchronized void start() {
                start0();
            }
            (2)
            //start0() 是本地方法，是JVM调用, 底层是c/c++实现
            //真正实现多线程的效果， 是start0(), 而不是 run
            private native void start0();

         */

        cat.start();//启动线程-> 最终会执行cat的run方法
        //cat.run();//不调用start方法直接调用，run方法就是一个普通的方法, 没有真正的启动一个线程，就会把run方法执行完毕，才向下执行，相当于串行化的过程，方法中打印的线程名依然是main会阻塞在这里



        //说明: 当main线程启动一个子线程 Thread-0, 主线程不会阻塞, 会继续执行
        //这时 主线程和子线程是交替执行..
        System.out.println("主线程继续执行" + Thread.currentThread().getName());//名字main
        for(int i = 0; i < 60; i++) {
            System.out.println("主线程 i=" + i);
            //让主线程休眠
            Thread.sleep(1000);
        }

    }
}

//老韩说明
//1. 当一个类继承了 Thread 类， 该类就可以当做线程使用
//2. 我们会重写 run方法，写上自己的业务代码
//3. run Thread 类 实现了 Runnable 接口的run方法
/*
    @Override
    public void run() {
        if (target != null) {
            target.run();
        }
    }
 */



class Cat extends Thread {

    int times = 0;
    @Override
    public void run() {//重写run方法，写上自己的业务逻辑

        while (true) {
            //该线程每隔1秒。在控制台输出 “喵喵, 我是小猫咪”
            System.out.println("喵喵, 我是小猫咪" + (++times) + " 线程名=" + Thread.currentThread().getName());
            //让该线程休眠1秒 ctrl+alt+t
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            if(times == 80) {
                break;//当times 到80, 退出while, 这时线程也就退出..
            }
        }
    }
}

实现Runnable接口

说明：

  1. java是单继承的，在某些情况下，一个类可能已经继承了某个父类，这时再继承Thread类方法来创建线程显然不可能了。
  2. java设计者提供了另一种创建线程方法，通过实现Runnable接口来创建
    定义类实现Runnable接口
class Dog implements Runnable { //通过实现Runnable接口，开发线程

    int count = 0;

    @Override
    public void run() { //普通方法
        while (true) {
            System.out.println("小狗汪汪叫..hi" + (++count) + Thread.currentThread().getName());

            //休眠1秒
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }

            if (count == 10) {
                break;
            }
        }
    }
}

但Runnable接口中没有start方法

public class Thread02 {
    public static void main(String[] args) {
        Dog dog = new Dog();
        //dog.start(); 这里不能调用start
        //创建了Thread对象，把 dog对象(实现Runnable),放入Thread
        Thread thread = new Thread(dog);
        thread.start();

//        Tiger tiger = new Tiger();//实现了 Runnable
//        ThreadProxy threadProxy = new ThreadProxy(tiger);
//        threadProxy.start();
    }
}

可以通过创建Thread对象来实现start方法，实际上底层使用了（静态）代理模式

class Animal {
}

class Tiger extends Animal implements Runnable {

    @Override
    public void run() {
        System.out.println("老虎嗷嗷叫....");
    }
}

//线程代理类 , 模拟了一个极简的Thread类
class ThreadProxy implements Runnable {//你可以把Proxy类当做 ThreadProxy

    private Runnable target = null;//属性，类型是 Runnable

    @Override
    public void run() {
        if (target != null) {
            target.run();//动态绑定（运行类型Tiger）
        }
    }

    public ThreadProxy(Runnable target) {
        this.target = target;
    }

    public void start() {
        start0();//这个方法时真正实现多线程方法
    }

    public void start0() {
        run();
    }
}


Tiger tiger = new Tiger();//实现了 Runnable
ThreadProxy threadProxy = new ThreadProxy(tiger);
threadProxy.start();

继承Thread和实现Runnable接口的区别
在这里插入图片描述

标题线程终止

  • 当线程完成任务后，会自动退出
  • 还可以通过使用变量来控制run方法退出的方式停止线程，也就是通知方式
public class ThreadExit_ {
    public static void main(String[] args) throws InterruptedException {
        T t1 = new T();
        t1.start();

        //如果希望main线程去控制t1 线程的终止, 必须可以修改 loop
        //让t1 退出run方法，从而终止 t1线程 -> 通知方式

        //让主线程休眠 10 秒，再通知 t1线程退出
        System.out.println("main线程休眠10s...");
        Thread.sleep(10 * 1000);
        t1.setLoop(false);
    }
}

class T extends Thread {
    private int count = 0;
    //设置一个控制变量
    private boolean loop = true;
    @Override
    public void run() {
        while (loop) {

            try {
                Thread.sleep(50);// 让当前线程休眠50ms
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println("T 运行中...." + (++count));
        }

    }

    public void setLoop(boolean loop) {
        this.loop = loop;
    }
}

线程中断

线程常用方法：
在这里插入图片描述
注意事项：
在这里插入图片描述
Interrupt方法：（并不终止，只是中断)

public class ThreadMethod01 {
    public static void main(String[] args) throws InterruptedException {
        //测试相关的方法
        T t = new T();
        t.setName("老韩");
        t.setPriority(Thread.MIN_PRIORITY);//1
        t.start();//启动子线程


        //主线程打印5 hi ,然后我就中断 子线程的休眠
        for(int i = 0; i < 5; i++) {
            Thread.sleep(1000);
            System.out.println("hi " + i);
        }

        System.out.println(t.getName() + " 线程的优先级 =" + t.getPriority());//1

        t.interrupt();//当执行到这里，就会中断 t线程的休眠.



    }
}

class T extends Thread { //自定义的线程类
    @Override
    public void run() {
        while (true) {
            for (int i = 0; i < 100; i++) {
                //Thread.currentThread().getName() 获取当前线程的名称
                System.out.println(Thread.currentThread().getName() + "  吃包子~~~~" + i);
            }
            try {
                System.out.println(Thread.currentThread().getName() + " 休眠中~~~");
                Thread.sleep(20000);//20秒
            } catch (InterruptedException e) {
                //当该线程执行到一个interrupt 方法时，就会catch 一个 异常, 可以加入自己的业务代码
                //InterruptedException 是捕获到一个中断异常.
                System.out.println(Thread.currentThread().getName() + "被 interrupt了");
            }
        }
    }
}

常用方法：
在这里插入图片描述

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

        T2 t2 = new T2();
        t2.start();

        for(int i = 1; i <= 20; i++) {
            Thread.sleep(1000);
            System.out.println("主线程(小弟) 吃了 " + i  + " 包子");
            if(i == 5) {
                System.out.println("主线程(小弟) 让 子线程(老大) 先吃");
                //join, 线程插队
                //t2.join();// 这里相当于让t2 线程先执行完毕
                Thread.yield();//礼让，不一定成功..
                System.out.println("线程(老大) 吃完了 主线程(小弟) 接着吃..");
            }

        }
    }
}

class T2 extends Thread {
    @Override
    public void run() {
        for (int i = 1; i <= 20; i++) {
            try {
                Thread.sleep(1000);//休眠1秒
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println("子线程(老大) 吃了 " + i +  " 包子");
        }
    }
}

用户线程和守护线程

  • 用户线程：也叫工作线程，当线程的任务执行完或通知方式结束
  • 守护线程：一般是为工作线程服务的，当所有的用户线程结束，守护线程自动结束
  • 常见的守护线程：垃圾回收机制

设置守护线程：
在这里插入图片描述

线程的生命周期

在这里插入图片描述
Runnable仅代表可以运行，但不一定running

在这里插入图片描述

线程同步

线程同步机制

  • 在多线程编程，一些敏感数据不允许被多个线程同时访问，此时就使用同步访问技术，保证数据在任何时刻，最多只有一个线程访问，以保证数据的完整性
  • 线程同步，也就是当有一个线程在对内存进行操作时，其他线程都不可以对这个内存地址进行操作，知道该线程完成操作，其他线程才能对该内存地址进行操作

实现同步方式：

1、 synchronized
在这里插入图片描述

互斥锁

  1. Java中，引入了对象互斥锁的概念，来保证共享数据操作的完整性。
  2. 每个对象都对应于一个可称为“互斥锁”的标记，这个标记用来保证在任一时刻只能有一个线程访问该对象
  3. 关键字synchronized来与对象互斥锁相联系，当某个对象用synchronized修饰时，表明该对象在任一时刻只能由一个线程访问
  4. 同步的局限性：程序的执行效率要降低
  5. 同步方法(非静态的)的锁可以是this，也可以是其他对象(要求时同一个对象)
  6. 同步方法(静态的)锁为当前类本身
public class SellTicket {
    public static void main(String[] args) {

        //测试
//        SellTicket01 sellTicket01 = new SellTicket01();
//        SellTicket01 sellTicket02 = new SellTicket01();
//        SellTicket01 sellTicket03 = new SellTicket01();
//
//        //这里我们会出现超卖..
//        sellTicket01.start();//启动售票线程
//        sellTicket02.start();//启动售票线程
//        sellTicket03.start();//启动售票线程


//        System.out.println("===使用实现接口方式来售票=====");
//        SellTicket02 sellTicket02 = new SellTicket02();
//
//        new Thread(sellTicket02).start();//第1个线程-窗口
//        new Thread(sellTicket02).start();//第2个线程-窗口
//        new Thread(sellTicket02).start();//第3个线程-窗口

        //测试一把
        SellTicket03 sellTicket03 = new SellTicket03();
        new Thread(sellTicket03).start();//第1个线程-窗口
        new Thread(sellTicket03).start();//第2个线程-窗口
        new Thread(sellTicket03).start();//第3个线程-窗口

    }
}


//实现接口方式, 使用synchronized实现线程同步
class SellTicket03 implements Runnable {
    private int ticketNum = 100;//让多个线程共享 ticketNum
    private boolean loop = true;//控制run方法变量
    Object object = new Object();


    //同步方法（静态的）的锁为当前类本身
    //老韩解读
    //1. public synchronized static void m1() {} 锁是加在 SellTicket03.class
    //2. 如果在静态方法中，实现一个同步代码块.使用如下方法
    /*
        synchronized (SellTicket03.class) {
            System.out.println("m2");
        }
     */
    public synchronized static void m1() {

    }
    public static  void m2() {
        synchronized (SellTicket03.class) {
            System.out.println("m2");
        }
    }

    //老韩说明
    //1. public synchronized void sell() {} 就是一个同步方法
    //2. 这时锁在 this对象
    //3. 也可以在代码块上写 synchronize ,同步代码块, 互斥锁还是在this对象
    public /*synchronized*/ void sell() { //同步方法, 在同一时刻， 只能有一个线程来执行sell方法

        synchronized (/*this*/ object) {
            if (ticketNum <= 0) {
                System.out.println("售票结束...");
                loop = false;
                return;
            }

            //休眠50毫秒, 模拟
            try {
                Thread.sleep(50);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }

            System.out.println("窗口 " + Thread.currentThread().getName() + " 售出一张票"
                    + " 剩余票数=" + (--ticketNum));//1 - 0 - -1  - -2
        }
    }

    @Override
    public void run() {
        while (loop) {

            sell();//sell方法是一共同步方法
        }
    }
}

//使用Thread方式
// new SellTicket01().start()
// new SellTicket01().start();
class SellTicket01 extends Thread {

    private static int ticketNum = 100;//让多个线程共享 ticketNum

//    public void m1() {
//        synchronized (this) {
//            System.out.println("hello");
//        }
//    }

    @Override
    public void run() {


        while (true) {

            if (ticketNum <= 0) {
                System.out.println("售票结束...");
                break;
            }

            //休眠50毫秒, 模拟
            try {
                Thread.sleep(50);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }

            System.out.println("窗口 " + Thread.currentThread().getName() + " 售出一张票"
                    + " 剩余票数=" + (--ticketNum));

        }
    }
}


//实现接口方式
class SellTicket02 implements Runnable {
    private int ticketNum = 100;//让多个线程共享 ticketNum

    @Override
    public void run() {
        while (true) {

            if (ticketNum <= 0) {
                System.out.println("售票结束...");
                break;
            }

            //休眠50毫秒, 模拟
            try {
                Thread.sleep(50);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }

            System.out.println("窗口 " + Thread.currentThread().getName() + " 售出一张票"
                    + " 剩余票数=" + (--ticketNum));//1 - 0 - -1  - -2

        }
    }
}

互斥锁注意事项

  1. 同步方法如果没有使用static修饰，默认锁对象为this
  2. 如果方法使用static修饰，默认锁对象：当前类.class
  3. 实现的落地步骤：
    (1)分析上锁的代码
    (2)选择== 同步代码块(优先选择) ==或者同步方法
    (3)要求多个线程的锁对象是同一个即可

线程死锁

多个线程都占用了对方的锁资源，但不肯相让，导致了死锁。

public class CpuNum {
    public static void main(String[] args) {
        //模拟死锁
        DeadLockDemo A = new DeadLockDemo(true);
        DeadLockDemo B = new DeadLockDemo(false);
        A.setName("A线程");
        B.setName("B线程");
        A.start();
        B.start();
    }
}


class DeadLockDemo extends Thread {
    static Object o1 = new Object();
    static Object o2 = new Object();
    boolean flag;

    public DeadLockDemo(boolean flag) {
        this.flag = flag;
    }

    @Override
    public void run() {
        if(flag) {
            synchronized (o1) {
                System.out.println(Thread.currentThread().getName() + " inter one");
                synchronized (o2) {
                    System.out.println(Thread.currentThread().getName() + " inter two");
                }
            }
        } else {
            synchronized (o2) {
                System.out.println(Thread.currentThread().getName() + " inter 3");
                synchronized (o1) {
                    System.out.println(Thread.currentThread().getName() + " inter 4");
                }
            }
        }
    }
}

释放锁

下面的操作会释放锁在这里插入图片描述
下面的操作不会释放锁
在这里插入图片描述

Java多线程实现方式2：runnable接口、龟兔赛跑案例
yalu_123456的博客
06-06 1300
实现Runnable 定义MyRunnable类实现Runnable接口 实现run()方法，编写线程执行体 创建线程对象，调用start()方法启动线程 案例： package MyDemo; //创建线程方式2：实现runnable接口 //1.实现接口 //2.重写run方法 //3.创建runbale接口实现类的对象。 //启动线程。需要创建一个线程Thread对象 ， 然后把runb...
如何实现多线程？实现多线程为什么要调start，而不是run方法？（继承Thread类、实现Ruable接口、Callable<V>）
sophia__yu的博客
11-11 1390
什么是进程？ 操作系统中一个程序的执行周期（从打开到关闭）。进程是具有一个或多个线程的线程组。 什么是线程？ 一个进程可以同时执行多个任务，任务就是线程，一个进程至少有一个线程。 线程运行在进程内部，线程是轻量级进程。 进程和线程比较: 与进程相比，线程更加轻量级，创建，撤销一个线程比启动、撤销一个进程开销小的多。一个进程中的所有线程共享此进程的所有的资源； 没有进程就没有线程，进程一旦终止...
Java多线程基础
qq_45574769的博客
08-15 113
总体概述： 先了解以下进程和线程： 进程 ： 每个进程包含独立的代码和数据空间，一个进程通常包含1 - n个线程 线程 ： 同一类线程共享代码和数据空间，每一个线程都有独立的运行栈和程序计数器 线程和进程类似，分为五个阶段：创建，就绪，运行，阻塞，终止。 多线程是指同时运行多个任务（程序）； Java中实现多线程常用有两种手段 ，一种是继承Thread类还有一种是实现Runable接口 一.继承Thread类 public class Thread1 ex
彻底理解Runnable和Thread的区别
blinkingsss的博客
09-27 6460
在实际工作中，我们很可能习惯性地选择Runnable或Thread之一直接使用，根本没在意二者的区别，但在面试中很多自以为是的菜货面试官会经常而且非常严肃的问出：请你解释下Runnable或Thread的区别？尤其是新手就容易上当，不知如何回答，就胡乱编一通。鄙人今天告诉你们这二者本身就没有本质区别，就是接口和类的区别。问出这个问题的面试官本身就是个二流子！如果非要说区别，请看如下： Runnable的实现方式是实现其接口即可 Thread的实现方式是继承其类 Runnable接口支持多继承，但基本上
java创建线程的2种方式
坚持需要成为习惯
12-20 466
1.创建一个实现Runbale接口的类，使用带参数的Thread构造器来创建Thread对象.(这个参数就是实现Runbale接口类的一个对象!)public class Calculator implements Runnable { public static void main(String[] args) { for (int i=1; i<10;i++){ Calculat
Java线程间同步互斥
03-17
Java线程间同步互斥，在实际的编程中，经常要处理线程间的同步互斥问题。Java 语言内在强大的多线程支持使得处理这类问题变得相对来说比较简单。本例将模仿经典的线程同步互斥例子——生产者和消费者问题，来演示 　...
Java 线程状态、线程池
01-20
java 线程状态、线程池 1. java 的线程状态 状态 发生条件 NEW 线程刚刚被创建，没有启动，没有调用start方法 RUNNABLE(可运行) 线程已经在JVM中运行，但是是否运行不确定，看当前线程是否由CPU执行权 ...
ｊａｖａ线程
09-28
程研究了线程的基础知识— 线程是什么、线程为什么有用以及怎么开始编写使用线程的简单 程序。 我们还将研究更复杂的、使用线程的应用程序的基本构件— 如何在线程之间交换数据、如何控制 线程以及线程如何互相通信...
Java线程模型缺陷
01-08
Java 编程语言的线程模型可能是此语言中最薄弱的部分。它完全不适合实际复杂程序的要求，而且也完全不是面向对象的。本文建议对 Java 语言进行重大修改和补充，以解决这些问题。 Java 语言的线程模型是此语言的一个...
Runnable
走在命运的左岸
01-18 1万+
Runnable 概述 java version “1.8.0_131” 多线程创建方式之一 public class RunnableTest implements Runnable{ // 实现 run() public void run() { System.out.println("thread"); } publ
实现线程第一种方法(不推荐)
iteye_2035的博客
01-31 109
[code="java"] package myPro1; //先继承类Thread，并复写run方法 public class FristThread extends Thread { @Override public void run() {//在run()里面，输入你要执行的代码 for (int i = 0; i < 100; i++) { System...
多线程简介与创建方式
zhangc
07-05 182
线程简介： 要想说线程，首先必须得聊聊进程，因为线程是依赖于进程存在的。 进程概述： 进程就是正在运行的程序，是执行程序的一次执行过程，一个动态的概念，是系统进行资源分配和调用的独立单位；每一个进程都有他独立的内存空间和系统资源； 线程概述： 在一个进程内部又可以执行多个任务，而这每一个任务我们就可以看成是一个线程。是程序使用CPU的基本单位。 多线程的意义： 多线程的作用不是提高执...
Java中Runnabale和Thread的区别
qbz_96的专栏
03-02 1058
在java中可有两种方式实现多线程，一种是继承Thread类，一种是实现Runnable接口； Thread类是在java.lang包中定义的。一个类只要继承了Thread类同时覆写了本类中的 run()方法就可以实现多线程操作了，但是一个类只能继承一个父类，这是此方法的局限， 下面看例子： package org.thread.demo; class MyThread extend
Runnable和Callable源码及应用解析
安余生的博客
07-07 3407
1、Runnable源码解析 看一下Runnable的源码，很简单 他的内容这么少是怎么实现我们繁杂的需求和应用呢？ 使用Runnable创建一个线程解析一下代码。 public static void main(String[] args) { new Thread(()->{ System.out.println("我是Runnable"); }).start(); } 里面使用Runnable的地方只有传递对
Java LIst集合全解
热门推荐
吾之奉先的博客
05-18 2万+
集合的优势： （1）数组存储的不足与缺陷： 长度开始必须执行，而且一旦指定，无法修改 保存的必须为同一类型的元素 使用数组进行增加/删除操作比较麻烦 （2）集合的好处： 可以动态保存多个对象，使用方便 提供了一系列方便的操作对象的方法，如add、remove、set、get等 使用集合增加/删除较方便 集合的框架图 (重要) 集合主要是两组：单列集合、双列集合 Collection接口有两个重要的子接口List、Set，他们的实现子类都是单列集合 Map接口的实现子类是双列集合，存放K-
Java·获取当前时间的三种方法
吾之奉先的博客
01-04 1万+
First： Date day=new Date(); SimpleDateFormat df = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss"); System.out.println(df.format(day)); Second： Date date = new Date(System.currentTimeMilli
Java Set集合详解
吾之奉先的博客
05-14 712
Set接口基本介绍： 1）无序(添加和取出顺序不一致)，没有索引 2）不允许重复元素，最多只能有一个 null 3）其实现类如下： Set接口常用方法： 和List接口一样，Set接口也是Collection的子接口，因此，常用方法和Collection接口一样 Set接口的遍历方式： 和Collection的遍历方式一样，1）可以使用迭代器，2）增强for 3）不能使用索引的方式来获取 public class SetMethod { public static ...
Java 向上转型和向下转型
吾之奉先的博客
04-19 595
多态的向上转型： （1）本质：父类的引用指向了子类对象 （2）语法： 父类类型 引用名 = new 子类类型()； （3）特点(规则)：编译类型看左边，运行类型看右边。 可以调用父类中的所有成员(遵守访问权限)(实际运行时需要遵守访问权限，大概，存疑) 不能调用子类特有成员(原因：在编译阶段，能调用哪些成员，是由编译类型来决定的) 最终运行效果由子类具体实现决定(调用方法时，按照...
Java线程高级实战指南
"Java线程高级使用教程" 本教程专注于Java线程的高级使用，适合已有一定Java基础，但对多线程和并发编程不太熟悉的开发者。由知名Java专家Brian Goetz撰写，他同时也是developerWorks Java技术专区的定期专栏作家。...
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值