Java多线程入门

最新推荐文章于 2024-09-20 15:32:13 发布
最新推荐文章于 2024-09-20 15:32:13 发布
阅读量158 收藏
点赞数 2
分类专栏： 入门引导 文章标签： java 多线程
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/swe50/article/details/107818513
版权

Java多线程入门

多线程概述

1. 线程与进程

进程
是指一个内存中运行的应用程序，每个进程都有一个独立的内存空间

线程
是进程中的一个执行路径，共享一个内存空间，线程之间可以自由切换，并发执行. 一个进程最少 有一个线程 。
线程实际上是在进程基础之上的进一步划分，一个进程启动之后，里面的若干执行路径又可以划分 成若干个线程。

2. 线程调度

  1. 分时调度：
    所有线程轮流使用 CPU 的使用权，平均分配每个线程占用 CPU 的时间。
  2. 优先让优先级高的线程使用 CPU，如果线程的优先级相同，那么会随机选择一个(线程随机性)。
    CPU使用抢占式调度模式在多个线程间进行着高速的切换。对于CPU的一个核新而言，某个时刻， 只能执行一个线程，而 CPU的在多个线程间切换速度相对我们的感觉要快，看上去就是 在同一时 刻运行。 其实，多线程程序并不能提高程序的运行速度，但能够提高程序运行效率，让CPU的 使 用率更高。

3. 线程的同步与异步

同步： 排队执行，效率低但是安全
异步： 同时执行， 效率高但是数据不安全.

Java简单实现多线程

1. Thread类

通过继承Thread类Override类方法run进行多线程
例：

public class MyThread extends Thread {

    /**
     * run方法是线程要执行的任务方法
     */
    @Override
    public void run() {
        // 这里的代码是一条新的执行路径
        // 这个执行路径的出发方式，不是调用run而是通过thread对象的start()来启动
        for(int i = 0; i < 10; i++) {
            System.out.println("haha" + i);
        }
    }
}

public class Demo {
    public static void main(String[] args) {
        MyThread m = new MyThread();
        m.start();
        for(int i = 0; i < 10; i++) {
            System.out.println("xixi" + i);
        }
    }
}


haha0
haha1
haha2
haha3
xixi0
xixi1
xixi2
xixi3
haha4
xixi4
haha5
xixi5
haha6
xixi6
haha7
haha8
haha9
xixi7
xixi8
xixi9

线程打印haha会和主方法里面打印xixi交替运行，顺讯不固定。

2. Runnable

通过实施Runnable接口来实现多线程

public class MyRunnable implements Runnable{
    /**
     * 用于给线程执行的任务
     */
    @Override
    public void run() {
        for(int i = 0; i < 10; i++) {
            System.out.println("haha" + i);
        }
    }
}


public class Demo {
    public static void main(String[] args) {
        // 实现Runnable
        // 创建一个任务对象
        MyRunnable r = new MyRunnable();
        // 创建一个线程，并为其分配一个任务
        Thread t = new Thread(r);
        // 执行线程
        t.start();
        for(int i = 0; i < 10; i++) {
            System.out.println("xixi" + i);
        }
    }
}

实现Runnable与继承Thread有如下优势：

  1. 通过创建任务然后给线程分配的方式来实现多线程，更适合多个线程同时执行相同任务情况。
  2. 避免单继承所带来的局限性。
  3. 任务与线程本身是分离的提高了程序的健壮性
  4. 后续的线程池技术接受Runnable，不接受Thread类型的线程。

3. 线程中断

一个线程是一个独立的执行路径，他是否应该结束，应该由其自身决定。
早起java提供了Thread.stop()方法从外部掐断线程，但是这样做会导致线程使用的资源来不及释放。现在已经为过时方法。
现在我们使用给线程打断点的方式中断线程
例： 实现线程中断

public class MyRunnable implements Runnable{
    /**
     * 用于给线程执行的任务
     */
    @Override
    public void run() {
        for(int i = 0; i < 10; i++) {
            System.out.println(Thread.currentThread().getName() + ":" + i);
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                System.out.println("发现中断标记，线程停止");
                return; // 资源释放
            }
        }
    }
}

public class Demo3 {
    public static void main(String[] args) {
        MyRunnable m = new MyRunnable();
        Thread t1 = new Thread(new Thread(m));
        t1.start();
        for(int i = 0; i < 5; i++) {
            System.out.println(i);
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
        t1.interrupt(); // 给子线程一个中断标记
    }
}

主线程for循环走完后会给interrupt标记进入子进程catch，然后子进程自我结束释放资源。

3. 线程安全问题

线程不安全是由于多个线程同时进行同时操作一个数据导致数据运行不符合预期。
线程不安全例子：

public class Demo4 {
    public static void main(String[] args) {
        // 线程不安全
        Runnable r = new Ticket();
        new Thread(r).start();
        new Thread(r).start();
        new Thread(r).start();
    }

    static class Ticket implements Runnable {
        // 卖票票数
        private int count = 10;
        @Override
        public void run() {
            while(count > 0) {
                System.out.println("准备卖票");
                try {
                    Thread.sleep(1000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                count--;
                System.out.println("出票成功， 余票：" + count);
            }
        }
    }
}


准备卖票
准备卖票
准备卖票
出票成功， 余票：9
准备卖票
出票成功， 余票：9
准备卖票
出票成功， 余票：9
准备卖票
出票成功， 余票：7
准备卖票
出票成功， 余票：7
准备卖票
出票成功， 余票：7
准备卖票
出票成功， 余票：6
准备卖票
出票成功， 余票：6
准备卖票
出票成功， 余票：6
准备卖票
出票成功， 余票：4
准备卖票
出票成功， 余票：4
准备卖票
出票成功， 余票：3
准备卖票
出票成功， 余票：2
准备卖票
出票成功， 余票：2
准备卖票
出票成功， 余票：2
准备卖票
出票成功， 余票：1
准备卖票
出票成功， 余票：1
准备卖票
出票成功， 余票：1
准备卖票
出票成功， 余票：0
出票成功， 余票：-2
出票成功， 余票：-2

Process finished with exit code 0

可以看到最后count结果是-2

解决方案：排队执行
1. 同步代码块
使用synchronized和锁类实现线程排队执行

public class Demo4 {
    public static void main(String[] args) {
        // 线程不安全
        // 解决方案1同步代码块
        // 格式synchronized(锁对象) {
        //
        // }
        Runnable r = new Ticket();
        new Thread(r).start();
        new Thread(r).start();
        new Thread(r).start();
    }

    static class Ticket implements Runnable {
        // 卖票票数
        private int count = 10;
        Object o = new Object(); // 定义一个锁对象o
        @Override
        public void run() {
            while(true) {
                synchronized (o) { // 使用锁同步代码块
                    if(count > 0) {
                        System.out.println("准备卖票");
                        try {
                            Thread.sleep(1000);
                        } catch (InterruptedException e) {
                            e.printStackTrace();
                        }
                        count--;
                        System.out.println(Thread.currentThread().getName() + "出票成功， 余票：" + count);
                    } else {
                        break;
                    }
                }
            }
        }
    }
}

准备卖票
Thread-0出票成功， 余票：9
准备卖票
Thread-0出票成功， 余票：8
准备卖票
Thread-0出票成功， 余票：7
准备卖票
Thread-0出票成功， 余票：6
准备卖票
Thread-0出票成功， 余票：5
准备卖票
Thread-0出票成功， 余票：4
准备卖票
Thread-0出票成功， 余票：3
准备卖票
Thread-0出票成功， 余票：2
准备卖票
Thread-0出票成功， 余票：1
准备卖票
Thread-0出票成功， 余票：0

Process finished with exit code 0

2. 同步方法
给方法添加synchronized修饰符来实现同步方法

public class Demo4 {
    public static void main(String[] args) {
        // 线程不安全
        // 解决方案1同步代码块
        // 格式synchronized(锁对象) {
        // 
        // }
        Runnable r = new Ticket();
        new Thread(r).start();
        new Thread(r).start();
        new Thread(r).start();
    }

    static class Ticket implements Runnable {
        // 卖票票数
        private int count = 10;
        Object o = new Object(); // 定义一个锁对象o
        @Override
        public void run() {
            while(true) {
                sale();
//                synchronized (o) {
//
//                }
            }
        }

        public synchronized boolean sale() { //给方法添加synchronized修饰符来实现同步方法
            if(count > 0) {
                System.out.println("准备卖票");
                try {
                    Thread.sleep(1000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                count--;
                System.out.println(Thread.currentThread().getName() + "出票成功， 余票：" + count);
            }
            return false;
        }
    }
}

3. 显示锁
同步代码块和同步方法属于隐式锁
例：

public class Demo4 {
    public static void main(String[] args) {
        // 线程不安全
        // 解决方案1同步代码块
        // 格式synchronized(锁对象) {
        //
        // }
        Runnable r = new Ticket();
        new Thread(r).start();
        new Thread(r).start();
        new Thread(r).start();
    }
    static class Ticket implements Runnable {
        // 卖票票数
        private int count = 10;
        // 显式锁l, ReentrantLock fair参数为true 就表示是公平锁（先来后到）
        Lock l = new ReentrantLock(true); 
        @Override
        public void run() {
            while (true) {
                    l.lock(); // 进程执行时锁上
                    if (count > 0) {
                        System.out.println("准备卖票");
                        try {
                            Thread.sleep(1000);
                        } catch (InterruptedException e) {
                            e.printStackTrace();
                        }
                        count--;
                        System.out.println(Thread.currentThread().getName() + "出票成功， 余票：" + count);
                    } else {
                        break;
                    }
                    l.unlock(); // 执行完毕解锁
            }
        }
    }
}

4. 线程的六种状态

在这里插入图片描述

  1. 初始(NEW)：新创建了一个线程对象，但还没有调用start()方法。
  2. 运行(RUNNABLE)：Java线程中将就绪（ready）和运行中（running）两种状态笼统的称为“运行”。
    线程对象创建后，其他线程(比如main线程）调用了该对象的start()方法。该状态的线程位于可运行线程池中，等待被线程调度选中，获取CPU的使用权，此时处于就绪状态（ready）。就绪状态的线程在获得CPU时间片后变为运行中状态（running）。
  3. 阻塞(BLOCKED)：表示线程阻塞于锁。
  4. 等待(WAITING)：进入该状态的线程需要等待其他线程做出一些特定动作（通知或中断）。
  5. 超时等待(TIMED_WAITING)：该状态不同于WAITING，它可以在指定的时间后自行返回。
  6. 终止(TERMINATED)：表示该线程已经执行完毕。

5. Runnable

Runnable 与 Callable
Callable接口类似于Runnable ，因为它们都是为其实例可能由另一个线程执行的类而设计的。 但是， Runnable不会返回结果，也不能抛出已检查的异常。

接口定义

//Callable接口
public interface Callable<V> {    
	V call() throws Exception; 
} 
//Runnable接口
public interface Runnable {    
	public abstract void run(); 
}

Callable使用步骤
在这里插入图片描述
例：

public class Demo6 {
    public static void main(String[] args) throws ExecutionException, InterruptedException {
        Callable<Integer> c = new Mycallable();
        FutureTask<Integer> task = new FutureTask<>(c);
        new Thread(task).start();
        Integer j = task.get();
        System.out.println("返回值为： " + j);
        for(int i = 0; i < 10; i++) {
            try {
                Thread.sleep(100);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println(i);
        }
    }

    static class Mycallable implements Callable<Integer> {

        @Override
        public Integer call() throws Exception {
            Thread.sleep(3000);
            return 100;
        }
    }
}

返回值为： 100
0
1
2
3
4
5
6
7
8
9

6. 线程池

如果并发的线程数量很多，并且每个线程都是执行一个时间很短的任务就结束了，这样频繁创建线程 就会大大降低 系统的效率，因为频繁创建线程和销毁线程需要时间. 线程池就是一个容纳多个线程的容 器，池中的线程可以反复使用，省去了频繁创建线程对象的操作，节省了大量的时间和资源

Java中的四种线程池 . ExecutorService
1. 缓存线程池
在这里插入图片描述
2. 定长线程池

在这里插入图片描述
3. 单线程线程池
在这里插入图片描述
4. 周期性任务定长线程池
在这里插入图片描述
在这里插入图片描述

swe50
关注
专栏目录
Java 多线程入门
qq_43164662的博客
11-22 481
Java 多线程入门，了解多个线程是如何同时进行的。
Java多线程入门超详解(小白也可以看懂的）
qq_41257358的博客
05-10 3056
Java多线程入门超详解(小白也可以看懂的 一、名词详解1.1 进程和线程1.2 并行和并发1.3 同步和异同步1.4 临界资源和临界区二、为什么要用多线程三、线程的五种状态四、Java创建线程的两种方法1、继承Thread类2、实现Runnable接口五、Java线程的常用方法1、wait()和notify()2、sleep()，yield()，join()3、setPriority()六、sy...
java多线程入门例子-第一例
java 菜鸟一枚
09-18 3202
– 认识多线程-1 多线程运行顺序基础举例 多线程数据共享基本例子
Java多线程详解（一）Java多线程入门
刘成
11-27 2269
最近听很多面试的小伙伴说，网上往往是一篇一篇的Java多线程的文章，除了书籍没有什么学习多线程的一系列文章。但是仅仅凭借一两篇文章很难对多线程有系统的学习，而且面试的时候多线程这方面的知识往往也是考察的重点，所以考虑之下决定写一系列关于Java多线程的文章。文章参考了高老师的《Java多线程编程核心技术》。力争使用最短的篇幅把Java多线程的知识作以系统的讲述。 本节思维导图： 思维导图...
Java多线程入门(二)
qq_44525150的博客
06-07 2063
本文简要介绍了Java多线程中的线程同步的作用，实现线程同步的三种方法，什么是线程死锁，线程死锁的例子，线程的状态，线程的生命周期
JAVA多线程使用,从入门到精通,看这一篇打开思路,豁然开朗
yyj12138的博客
01-30 816
java多线程;线程创建;线程池;线程池参数;面试八股文;java创建线程的方式;多线程入门;多线程看这一篇就够了
Java多线程学习（吐血超详细总结）
热门推荐
Evankaka的专栏
03-14 41万+
本文主要讲了java中多线程的使用方法、线程同步、线程数据传递、线程状态及相应的一些线程函数用法、概述等。
Java多线程入门篇（三）Java线程间的通信（锁，等待/通知，信号量，管道）
wangdawei_的博客
02-28 821
java多线程入门篇 （三） 锁与同步等待/通知机制信号量：管道：其它通信相关join方法sleep方法ThreadLocal类InheritableThreadLocal   在Java中合理的使用多线程可以更好的利用服务器资源。一般来说，线程都有自己的自由线程上下文，互不干扰。但是当我们需要多个线程之间互相协作的时候，就需要掌握Java线程的通信方式才可以 锁与同步   在Java中锁都是基于对象的，所以又称为对象锁。锁与线程的关系就像婚姻关系，一个锁在同一时间只能由一个线程持有，只有当持有锁的线程释放
002-Java多线程入门学习
qq_40488788的博客
11-24 331
Java多线程入门学习 ​ 狂神说Java多线程模块总结篇-凡人就该保留偏执的权利-kxd@my.swjtu.edu.cn 一.线程，进程，多线程 程
编程必备：JAVA多线程详解
拾一二的博客
06-14 8566
多线程已经成为一种常见的编程模式，广泛应用于各种不同类型的应用程序中。本篇博客文章中，我们将会探讨多线程编程的相关知识和技巧。通过代码示例和实际应用案例来深入了解多线程的具体实现和应用方法，帮助更好地掌握多线程编程技术，提高程序效率和性能。后期随学习深入还会补充修改。以上就是我对多线程的个人简介，后续会不断完善更新，与大家共勉。
java多线程入门
06-13
### Java多线程入门 #### 一、进程与线程的区别 在理解Java中的多线程之前，我们先来看看进程和线程之间的区别。 - **进程**：进程是程序的一次执行过程，它是系统进行资源分配和调度的一个独立单位。每个进程都...
JAVA多线程入门基础知识
02-22
必知必会的多线程入门基础知识
java多线程入门知识及示例程序
09-04
"Java多线程入门知识及示例程序" Java多线程是一种非常重要的编程技术，它可以帮助开发者创建高效、可扩展的程序。多线程的出现是为了解决某些问题，如图形界面的出现、输入、输出的阻塞和多核CPU的更好利用等。 ...
java多线程入门的源代码
03-28
Java多线程是Java开发中的重要概念，它允许程序同时执行多个任务，提高了程序的效率和响应速度。在Java中，实现多线程有两种主要方式：继承Thread类和实现Runnable接口。 1. 继承Thread类： 当一个类继承了Thread...
Java-网络
2301_81543552的博客
09-14 796
Java中的网络编程主要涉及使用Socket类进行网络通信，以及理解各种网络协议。以下是一些关键概念和示例代码，帮助您入门。
Java企业面试题3
m0_74972727的博客
09-15 834
1. break和continue的作用(智*图) break：用于完全退出一个循环（如 for, while）或一个 switch 语句。当在循环体内遇到break语句时，程序会立即跳出当前循环体，继续执行循环之后的代码。 continue：用于跳过当前循环体中剩余的部分，并开始下一次循环。如果是在 for 循环中使用continue，则会直接进行条件判断以决定是否执行下一轮循环。 2. if分支语句和switch分支语句的异同之处(智*图) 相同点：都是用来根据不同的条件执行不同的代码块。
上传文件到钉盘流程详解
jspyth的博客
09-14 812
本文详解如何通过钉钉的API实现上传文件到钉盘目录，代码通过JAVA实现。
JDK17新增语法特性
最新发布
2201_76124988的博客
09-20 339
从springboot3.0开始，已经不支持JDK8，转变为JDK17参考资料：官方博客。
faiss安装 （CPU版本）
CSDN_WHB的博客
09-20 133
faiss版本 faiss-v1.7.4。
Java多线程入门与线程安全
"这篇资料是关于Java多线程的学习材料，由高级软件人才实作培训专家北京传智播客教育提供，由讲师毕向东讲解。资料涵盖了多线程的基础概念，如进程、线程的创建与状态，以及线程安全问题和同步机制。" Java多线程是...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值