java基础之多线程

最新推荐文章于 2024-06-13 08:37:22 发布
最新推荐文章于 2024-06-13 08:37:22 发布
阅读量55 收藏
点赞数 1
文章标签： java 多线程
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_39176095/article/details/116543876
版权

一、线程、进程

1.概念

  1. 进程是程序一次执行的过程，或是正在运行中的程序，是静态的概念
  2. 线程是一个任务从头到尾的执行过程，是动态的概念
  3. 一个进程同一时间并行执行多个线程，就是支持多线程的
  4. 并行和并发：并行是多个CPU同时执行多个任务，并发是一个CPU执行多个任务

2.线程的创建

三种：线程的三种创建方式

方法一：继承Thread类

步骤：

  1. 定义子类继承Thread，使其成为线程类
  2. 子类中重写Thread类中的run方法
  3. 创建子类的对象，再调用start方法启动线程

源码分析：

package com.tang.dem01;

/**
 * @author tanglei
 * @create 2021-05-09 8:35
 * 创建线程方式一：继承Thread类，重写run()方法，调用start开启线程
 * 线程开启不一定就立即开始执行，由CPU调度执行
 */
public class TestThread1 extends Thread{//第一步继承
    @Override
    public void run() {//第二步重写run
        //run方法线程体
        for (int i = 0; i < 20; i++) {
            System.out.println("副线程---");
        }
    }

    public static void main(String[] args) {
        //主线程
        TestThread1 testThread1 = new TestThread1();
        testThread1.start();//第三步：创建对象调用start

        for (int i = 0; i < 20; i++) {
            System.out.println("主线程" + i);
        }
    }
}

方法二：实现Runnable接口

步骤：

  1. 实现Runnable接口
  2. 重写run方法，在run里面执行线程
  3. 在主函数里创建接口实现类的对象
  4. 再在主函数里面创建线程Thread对象，将接口类的实现对象传入进去
  5. 调用start方法

源码分析：

package com.tang.dem01;

/**
 * @author tanglei
 * @create 2021-05-09 9:00
 *实现接口，重写run，丢入接口实现类，调用start方法
 */
public class TestThread2 implements Runnable{
    @Override
    public void run() {
        //run方法线程体
        for (int i = 0; i < 1000; i++) {
            System.out.println("副线程---");
        }
    }

    public static void main(String[] args) {
        //创建runnable接口的实现类对象
        TestThread2 testThread2 = new TestThread2();
        //创建线程对象，通过线程对象来开启线程
        Thread thread = new Thread(testThread2);
        thread.start();

        for (int i = 0; i < 1000; i++) {
            System.out.println("主线程" + i);
        }
    }
}

方法三：实现Callable接口

步骤：

  1. 实现Callable接口，需要返回值类型
  2. 重写call方法，需要抛出异常
  3. 创建目标对象（到此为止，和前面两种方法差不多）
  4. 创建执行服务：ExecutorService ser = Executors.newFixedThreadPool(n);//这里的n表示线程数目
  5. 提交执行：Future<Boolean> result1 = ser.submit(t1);
  6. 获取结果：boolean r1 = result1.get();
  7. 关闭服务：ser.shutdownNow();

3.前两种方法创建线程的区别

  • 继承Thread是将线程代码存放在Thread子类的run方法中
  • 实现Runnable是存放在接口的子类的run方法中
  • 通常采用实现Runnable的方式，这样可以避免单继承的局限性，多个线程可以共享一个接口实现类的对象，适合多个相同线程来处理同一份资源

4.龟兔赛跑实例------巩固多线程

思路：

  • 首先要一个赛道，离终点越来越近，for循环累加实现
  • 创建判断比赛是否结束方法，通过步数判定，打印出胜利者
  • 通过延迟来模拟兔子睡觉

源码分析：

package com.tang.dem01;

/**
 * @author tanglei
 * @create 2021-05-09 9:21
 */
public class Race implements Runnable{
    //胜利者
    private static String winner;
    @Override
    public void run() {
        for (int i = 0; i <= 100; i++) {
            //模拟兔子睡觉
            if (Thread.currentThread().getName().equals("兔子") && i%10==0){
                try {
                    Thread.sleep(5);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
            //判断比赛是否结束
            boolean flag = gameOver(i);
            if(flag){
                break;
            }
            System.out.println(Thread.currentThread().getName()+ "---跑了" + i + "步");

        }
    }
    //判断是否完成比赛
    private boolean gameOver(int steps){
        //判断是否有胜利者
        if(winner != null){
            return true;
        }else if(steps >= 100){
            winner = Thread.currentThread().getName();
            System.out.println("winner is "+ winner);
            return true;
        }
        return false;
    }

    public static void main(String[] args) {
        Race race = new Race();
        new Thread(race,"兔子").start();
        new Thread(race,"乌龟").start();
    }
}

5.静态代理

方法：

  • 定义一个接口
  • 被代理类去实现该接口
  • 代理类去实现该接口，定义被代理类对象，构造函数传参
  • 在被代理类实现该接口的前后可以加入方法
  • 在主函数中创建代理类对象，再将被代理类作为参数传入代理类，调用实现接口的方法

特点：被代理（真实）对象和代理对象都要实现同一个接口，将被代理对象作为参数传入代理类。

源源码分析：

package com.tang.dem02;

/**
 * @author tanglei
 * @create 2021-05-09 9:59
 */
public class StaticProxy {
    public static void main(String[] args) {
        WeddingCompany weddingCompany = new WeddingCompany(new You());
        weddingCompany.HappyMarry();
    }
}
interface Marry{
    void HappyMarry();
}
//被代理类
class You implements Marry{
    @Override
    public void HappyMarry() {
        System.out.println("要结婚了");
    }
}
//代理类
class WeddingCompany implements Marry{
    private Marry target;

    public WeddingCompany(Marry target) {
        this.target = target;
    }

    @Override
    public void HappyMarry() {
        before();
        this.target.HappyMarry();
        after();
    }

    private void after() {
        System.out.println("结婚之后");
    }

    private void before() {
        System.out.println("结婚之前");
    }
}

结果：
静态代理结果

6. Lamda表达式

函数式接口：任何接口，如果只包含了唯一一个抽象方法，那就是一函数式接口，就可以用Lamda表达式来表示。例如：

package com.tang.dem02;

/**
 * @author tanglei
 * @create 2021-05-09 10:31
 */
public class LamdaTest {
//    //3.静态内部类
//    static class Like2 implements ILike{
//        @Override
//        public void lambda() {
//            System.out.println("I lIKE lambda2");
//        }
//    }

    public static void main(String[] args) {
        ILike like = new Like();
        like.lambda();
//        Like2 like2 = new Like2();
//        like2.lambda();

//        //4.局部内部类
//        class Like3 implements ILike{
//            @Override
//            public void lambda() {
//                System.out.println("I lIKE lambda3");
//            }
//        }
//        like = new Like3();//Like3 like3 = Like3();
//        like.lambda();//like3.lambda();

//        //5.匿名内部类,没有类的名称，必须借助接口或者父类
//        like = new ILike() {
//            @Override
//            public void lambda() {
//                System.out.println("I lIKE lambda4");
//            }
//        };//这相当于一行语句，需要加分号
//        like.lambda();

        //6.用lambda简化
        like = ()->{
            System.out.println("I lIKE lambda5");
        };
        like.lambda();
    }
}
//1.定义一个函数式接口
interface ILike{
    void lambda();
}
//2.实现类
class Like implements ILike{
    @Override
    public void lambda() {
        System.out.println("I lIKE lambda");
    }
}
}

7. 线程方法

1.线程停止 stop：

不推荐使用stop(),destory()方法，推荐自定义标志位来停止。
停止线程

2.线程休眠 sleep：

每个线程都有一把锁，sleep不会释放锁。

3.线程礼让 yield：

让当前正在执行的线程暂停，但不阻塞，重新让CPU调度，让线程从运行状态转为就绪状态，礼让不一定成功。

package com.tang.dem02;

/**
 * @author tanglei
 * @create 2021-05-09 14:18
 */
public class TestYield {
    public static void main(String[] args) {
        MyYield myYield = new MyYield();

        new Thread(myYield,"a").start();
        new Thread(myYield,"b").start();
    }
}
class MyYield implements Runnable{
    @Override
    public void run() {
        System.out.println(Thread.currentThread().getName() +"线程开始执行");
        Thread.yield();//礼让
        System.out.println(Thread.currentThread().getName()+ "线程停止执行");
    }
}

结果：正常来说应该输出a线程执行开始到停止才到b线程执行，但是礼让之后就会可能让a,b都开始执行再停止执行。

4.线程合并 join：

待此线程执行完成后，再执行其他线程，其他线程阻塞，相当于插队。

package com.tang.dem02;

/**
 * @author tanglei
 * @create 2021-05-09 14:27
 */
public class TestJoin implements Runnable{
    @Override
    public void run() {
        for (int i = 0; i < 10; i++) {
            System.out.println("线程vip来了");
        }
    }

    public static void main(String[] args) throws InterruptedException {
        //启动自己的线程
        TestJoin testJoin = new TestJoin();
        Thread thread = new Thread(testJoin);
        thread.start();

        //主线程
        for (int i = 0; i < 100; i++) {
            if (i == 20) {
                thread.join();
            }
            System.out.println("main" + i);
        }
    }
}

结果：
线程合并

8. 线程状态

线程状态转换图

package com.tang.dem02;

/**
 * @author tanglei
 * @create 2021-05-09 14:42
 */
public class TestState {
    public static void main(String[] args) throws InterruptedException {
        Thread thread = new Thread(()->{
            for (int i = 0; i < 5; i++) {
                try {
                    Thread.sleep(1000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
            System.out.println("--------");
        });
        //观察状态
        Thread.State state = thread.getState();
        System.out.println(state);// NEW
        //观察启动后
        thread.start();//启动线程
        state = thread.getState();
        System.out.println(state);//Run

        while (state != Thread.State.TERMINATED){//只要线程不终止，就一直输出状态
            Thread.sleep(100);
            state = thread.getState();//更新状态
            System.out.println(state);
        }

    }
}

结果：

在这里插入图片描述
…
在这里插入图片描述

9. 守护线程 daemon

  • 线程分为用户线程和守护线程
  • 虚拟机必须确保用户线程执行完毕：如man()；
  • 虚拟机不用等待守护线程执行完毕：如gc();

10. 线程同步

synchorized关键字可以加锁，保持同步，没有竞争才算线程安全；
调用对象上的同步实例方法需要给对象加锁，调用一个类上的同步静态方法需要给类加锁。
死锁：某一个代码块同时拥有两个以上对象的锁，就会发生死锁。
package com.tang.dem02;

/**
 * @author tanglei
 * @create 2021-05-09 15:28
 */
public class DeadLock {
    public static void main(String[] args) {
        Makeup g1 = new Makeup(0,"灰姑凉");
        Makeup g2 = new Makeup(1,"白雪公主");
        g1.start();
        g2.start();
    }
}
//口红
class Lipstick{

}
//镜子
class Mirror{

}
class Makeup extends Thread {

    //需要的资源只有一份，用static来保证只有一份
    static Lipstick lipstick = new Lipstick();
    static Mirror mirror = new Mirror();

    int choice;
    String girlname;

    Makeup(int choice, String girlname) {
        this.choice = choice;
        this.girlname = girlname;
    }

    @Override
    public void run() {
        //化妆
        try {
            makeup();
        } catch (InterruptedException e) {
            e.printStackTrace();
        }

    }

    private void makeup() throws InterruptedException {
        if (choice == 0) {
            synchronized (lipstick) {//获得口红的锁
                System.out.println(this.girlname + "获得口红的锁");
                Thread.sleep(1000);

                }
            synchronized (mirror) {
                System.out.println(this.girlname + "获得镜子的锁");

            }
        } else {
            synchronized (mirror) {//获得口红的锁
                System.out.println(this.girlname + "获得镜子的锁");
                Thread.sleep(2000);


            }
            synchronized (lipstick) {
                System.out.println(this.girlname + "获得口红的锁");
            }
        }
    }
}
Lock
  • lock():得到一个锁，unlock释放锁，encondition()返回一个绑定到改lock实例的condition对象
  • ReentrantLock是lock的一个具体实现，该方法用于创建相互排斥的锁，可以创建具有特定的公平策略的锁。如果公平策略为真，则确保等待时间最长的线程首先获得该锁
ReentrantLock lock = new ReentranLock();
try{
lock.lock;//加锁
}catch{
...
}
finally{
lock.unlock//解锁
}

对比

11. 线程协作

通过创建lock对象的newCondition（）方法而创建的对象。
await()让当前线程进入等待，直到条件发生，sinal()方法唤醒一个等待的线程，而signalAll()唤醒所有等待的线程。
协作
生产者和消费者问题。

package com.tang.dem02;

/**
 * @author tanglei
 * @create 2021-05-09 15:55
 * //利用缓冲区解决：管程法
 */
public class TestPC {
    public static void main(String[] args) {
        SynContainer container = new SynContainer();
        new Productor(container).start();
        new Consumer(container).start();
    }

}
//生产者
class Productor extends Thread{
    SynContainer container;
    public Productor(SynContainer container){
        this.container = container;
    }
    @Override
    public void run() {
        for (int i = 0; i < 100; i++) {
            container.push(new Chicken(i));
            System.out.println("生产了" + i + "只鸡");
        }
    }

}
//消费者
class Consumer extends Thread{
    SynContainer container;
    public  Consumer(SynContainer container){
        this.container = container;
    }

    @Override
    public void run() {
        for (int i = 0; i < 100; i++) {
            System.out.println("消费了" + container.pop().id + "只鸡");

        }
    }
}
//产品
class Chicken{
    int id;

    public Chicken(int id) {
        this.id = id;
    }
}
//缓冲区
class SynContainer{
    //容器大小
    Chicken[] chickens = new Chicken[10];
    //容器计数器
    int count =0;

    //生产者生产产品
    public synchronized void push(Chicken chicken){
        //如果容器满了，就需要等待消费者消费
        if(count == chickens.length){
            //通知消费者消费,生产者等待
            try {
                this.wait();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }


        }
        //如果容器没有满那么就需要生产产品
        chickens[count]=chicken;
        count++;
        this.notify();

    }

    //消费者消费产品
    public synchronized Chicken pop(){
        if(count==0){
            try {
                this.wait();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }

        }
        count--;
        Chicken chicken = chickens[count];

        this.notifyAll();
        return chicken;
    }
}

12. 线程池

线程池

package com.tang.dem02;

import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;

/**
 * @author tanglei
 * @create 2021-05-09 16:21
 */
public class TestPool {
    public static void main(String[] args) {
        //1.创建线程池
        //newFixedThreadPool 参数为线程池大小
        ExecutorService service = Executors.newFixedThreadPool(10);
        //执行
        service.execute(new MyThread());
        service.execute(new MyThread());
        service.execute(new MyThread());
        service.execute(new MyThread());
        //2.关闭连接
        service.shutdown();
    }
}
class MyThread implements Runnable{
    @Override
    public void run() {
            System.out.println(Thread.currentThread().getName());
    }
}
不懂程序的程序猿
关注
  • 1
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
Java基础之多线程
08-26
以下是我们Java基础多线程的一些知识点总结，看完以后会觉得多线程也可以这么简单，小编精心推荐，希望能对大家有所帮助
Java基础之多线程.md
11-10
Java多线程，Java基础，并发
java基础之多线程的引入
weixin_50691399的博客
11-03 2475
本文主要是引入多线程
Java基础——多线程详解！！！！
qq_52519008的博客
10-04 4653
就是进程中的一个独立控制单元，线程在控制着进程的执行。一个进程中至少有一个进程。多线程是多任务的一种特别的形式，但多线程使用了更小的资源开销。多线程能满足程序员编写高效率的程序来达到充分利用 CPU 的目的。注意：很多多线程是模拟出来的，真正的多线程是指有多个CPU，即多核，如服务器。如果是模拟出来的多线程，即在一个CPU的情况下，在同一个时间点，CPU只执行一个代码，因为切换得很快，所以就有同时执行的错觉。程序、进程和线程的大家可以通过百度搜索得知，在这里我就不多阐述。
Java 多线程编程基础(详细)
一夜星尘
11-03 3万+
Java多线程编程基础进程与线程多线程实现Thread类实现多线程Runnable接口实现多线程Callable接口实现多线程多线程运行状态多线程常用操作方法线程的命名和获取线程休眠线程中断线程强制执行线程让步线程优先级设定线程的同步和锁死线程同步处理线程死锁 进程与线程 进程与线程的基本认识 进程（Process）：进程是程序的一次动态执行过程，它经历了从代码加载、执行、到执行完毕的一个完整过程；同时也是并发执行的程序在执行过程中分配和管理资源的基本单位，竞争计算机系统资源的基本单位。 线程（Thread
Java面试之多线程篇
qq_24095055的博客
03-14 3296
Java面试之多线程篇 篇章 个人博客链接 多线程基础
Java多线程（超详细！）
热门推荐
一只小菜鸡
05-13 12万+
1、什么是进程？什么是线程？ 进程是:一个应用程序（1个进程是一个软件）。 线程是：一个进程中的执行场景/执行单元。 注意：一个进程可以启动多个线程。 eg.对于java程序来说，当在DOS命令窗口中输入： java HelloWorld 回车之后。 会先启动JVM，而JVM就是一个进程。 JVM再启动一个主线程调用main方法。 同时再启动一个垃圾回收线程负责看护，回收垃圾。 最起码，现在的java程序中至少有两个线程并发， 一个是垃圾回收线程，一个是执行main方法的主线程。 3、进程和线程是什么关系？
java多线程（超详细）
zdl66的博客
08-14 10万+
进程就是正在运行中的程序（进程是驻留在内存中的）是系统执行资源分配和调度的独立单位每一进程都有属于自己的存储空间和系统资源注意：进程A和进程B的内存独立不共享。
Java多线程实战-实现多线程文件下载，支持断点续传、日志记录等功能
qq_35716689的博客
03-10 9万+
本文将介绍如何通过Java来实现一个多线程下载器。作者：牵着猫散步的鼠鼠
Java基础之——Java 线程
前尘忆梦的博客
02-03 4759
Java 线程 1、创建线程类（方法一） Java使用 java.lang.Thread 类代表线程，所有的线程对象都必须是 Thread 类或其子类的实例。每个线程的作用是完成一定的任务，实际上就是执行一段程序流即一段顺序执行的代码。Java 使用线程执行体来代表这段程序流。 Java 中通过继承 Thread 类来创建并启动多线程的步骤如下： 定义 Thread 类的子类，并重写该类的 run() 方法，该 run() 方法的方法体就代表了线程需要完成的任务，因此把 run() 方法称为线程执行体。
Java基础进阶多线程概述
qq_46096136的博客
09-11 6360
CPU的处理速度极快，多个线程之间频繁切换执行，跟人来的感觉是：多个事情。不能够做到真正的多线程并发，但是可以做到给人一种“多线程并发”的感觉。对于单核的CPU来说，在某一个时间点上实际上只能处理一件事情，但是由于。线程A和线程B频繁切换执行，人类会感觉音乐一直在播放，游戏一直在运行，一根钢针扎到手上，到最终感觉到疼，这个过程是需要“很长的”时间的，在。我在窗口1购票，你可以在窗口2购票，你不需要等我，我也不需要等你。人类的眼睛产生了错觉，感觉是动画的。一个是垃圾回收线程，一个是执行main方法的主线程。
java中多线程之volatile详解（最通俗）
易柏州的博客
07-29 1万+
java中多线程之volatile详解     什么是volatile volatile是JVM提供的轻量级同步机制 好，开始讲大家看不懂的东西了！ volatile有三大特性： 保证可见性 不保证原子性 禁止指令重排 傻了吧，这他妈都是些什么jb东西啊？别着急，我们一个一个来。 在学习volatile之前，我们先了解一下JMM。什么又是JMM？我只知道JVM。这他妈是啥东西啊？ JMM：java内存模型。jmm是一种抽象的概念，并不真实存在，它描述的是一种规范，通过这种规范定义了程序中的各个变量的访问
java基础之多线程讲解
04-09
java基础之多线程讲解
Java基础多线程.xmind
09-20
个人关于java基础多线程的思维导图总结。0积分下载。如果认为有帮助，请关注点赞，日后还有更多免费资源。
JAVA之多线程（基础图）
02-20
JAVA之多线程（基础图）
简单的项目部署脚本（转载）
u010230019的博客
06-09 672
有些项目团队喜欢使用docker启动java服务,那么我们同样可以将上述脚本稍做改造,来实现基于shell+docker的简单项目部署能力。可以将核心节点的错误或者失败内容通过webhook发送到对应的告警平台,比如钉钉、飞书机器人等。把~/.ssh/id_rsa.pub内容添加到远程仓库的ssh秘钥中。执行start.sh脚本打包部署。start.sh脚本内容。
Java——简单图书管理系统
m0_74100417的博客
06-09 1520
数据类型变量iffor数组方法类和对象封装继承多态抽象类和接口今天就是把上述知识点全部都用起来 图书管理系统图书管理系统图书管理系统图书管理系统图书管理系统图书管理系统图书管理系统图书管理系统图书管理系统图书管理系统图书管理系统图书管理系统图书管理系统图书管理系统图书管理系统图书管理系统图书管理系统图书管理系统图书管理系统图书管理系统图书管理系统图书管理系统图书管理系统图书管理系统图书管理系统图书管理系统图书管理系统图书管理系统图书管理系统图书管理系统图书管理系统图书管理系统图书管理系统图书管理系统图书管理
修改菜品——后端Java
weixin_53717695的博客
06-09 499
修改菜品——后端Java
Spring Boot集成antlr实现词法和语法分析
最新发布
HBLOG
06-13 845
Antlr4 是一款强大的语法生成器工具，可用于读取、处理、执行和翻译结构化的文本或二进制文件。基本上是当前 Java 语言中使用最为广泛的语法生成器工具。Twitter搜索使用ANTLR进行语法分析，每天处理超过20亿次查询；Hadoop生态系统中的Hive、Pig、数据仓库和分析系统所使用的语言都用到了ANTLR；Lex Machina将ANTLR用于分析法律文本；Oracle公司在SQL开发者IDE和迁移工具中使用了ANTLR；NetBeans公司的IDE使用ANTLR来解析C++；
Java多线程基础，创建线程
05-14
创建线程是Java多线程的基础，下面介绍两种创建线程的方式。 方式一：继承Thread类 继承Thread类是创建线程的一种方式，它需要重写Thread类的run()方法来定义线程的行为。 ```java public class MyThread extends...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值