java基础之多线程

已于 2023-10-27 18:00:49 修改
阅读量37 收藏 1
点赞数 1
文章标签： java 1024程序员节
于 2023-10-24 16:00:36 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_46375204/article/details/134011508
版权
1. 程序、进程与线程
  1. 程序是为完成特定任务、用某种语言编写的一组指令的集合。
  2. 进程是正在运行的一个程序，是操作系统调度和资源分配的基本单位。 
  3. 线程是一个进程内部的一条执行路径，是CPU调度和资源分配的基本单位。
2. 多线程的优点
  1. 提高应用程序的响应速度，可增强用户体验。
  2. 提高计算机系统CPU的利用率。
  3. 改善程序结构。
 3.并行与并发
  1. 并行是指多个CPU在同一时刻执行多个任务。
  2. 并发是一个CPU在一个时间段内执行多个任务。
4.创建线程
        4.1继承Thread,重写run方法，调用start动线程
/**
 *      继承Thread,重写run方法，调用start启动线程
 */
public class CusThread extends Thread{
    /**
     * main方法的线程是：main
     * run方法的线程是：Thread-0
     * 线程执行体
     */
    @Override
    public void run() {
        System.out.println("run方法的线程是：" + Thread.currentThread().getName());
        System.out.println("线程执行体");
    }
    public static void main(String[] args) {
        System.out.println("main方法的线程是：" + Thread.currentThread().getName());
        CusThread thread = new CusThread();
        thread.start();
    }
}
                4.1.1 能否调用run方法代替start方法？

                        不能，调用run方法只是单纯的执行run方法体，而start方法会创建一个新的线程去执行run方法体。

                4.1.2 已经调用start方法的线程，能否再去调用start方法？

                        不能，会抛出 IllegalThreadStateException 的异常。

public synchronized void start() {
        
        if (threadStatus != 0)
            throw new IllegalThreadStateException();
        /**
        *    省略代码...
        */
    }
        4.2 实现Runnable接口, 重写run方法，调用start启动线程
/**
 *      实现Runnable接口, 重写run方法，调用start启动线程
 */
public class CusThread implements Runnable{
    /**
     * main方法的线程是：main
     * run方法的线程是：Thread-0
     * 线程执行体
     */
    @Override
    public void run() {
        System.out.println("run方法的线程是：" + Thread.currentThread().getName());
        System.out.println("线程执行体");
    }
    public static void main(String[] args) {
        System.out.println("main方法的线程是：" + Thread.currentThread().getName());
        Runnable runnable = new CusThread();
        Thread thread = new Thread(runnable);
        thread.start();
    }
}

         Thead类实际上也是Runnable接口的实现类

public class Thread implements Runnable {

    private Runnable target;

    private Thread(ThreadGroup g, Runnable target, String name,
                   long stackSize, AccessControlContext acc,
                   boolean inheritThreadLocals) {
                /**
                 * 省略代码...
                 */
                this.target = target;
                /**
                 * 省略代码...
                 */
    }

    @Override
    public void run() {
        if (target != null) {
            target.run();
        }
    }
}
        4.3 实现Callable接口, 重写run方法，调用start启动线程

        调用get方法获取返回值会阻塞当前线程的执行，等到分线程执行完毕。

/**
 *      实现Callable接口, 重写run方法，调用start启动线程
 */
public class CusThread implements Callable<Integer> {

    @Override
    public Integer call() throws Exception {
        return 2<<3;
    }

    public static void main(String[] args){
        CusThread cusThread = new CusThread();
        FutureTask<Integer> futureTask = new FutureTask(cusThread);
        Thread thread = new Thread(futureTask);
        thread.start();
        Integer result = null;
        try {
            result = futureTask.get();
        } catch (Exception e) {
            e.printStackTrace();
        }
        System.out.println(result);
    }
}
5.常用方法
        5.1 启动线程
public synchronized void start(){}
        5.2 返回当前线程
public static native Thread currentThread();
        5.3 休眠一段时间（不会放弃锁）
public static native void sleep(long millis) throws InterruptedException;
        5.4 线程让步
public static native void yield();
         5.5 阻塞线程，直到join() 方法加入的join 线程执行完为止
public final void join() throws InterruptedException {}
        5.6 是否存活
public final native boolean isAlive();
        5.7.获取线程优先级
public final int getPriority(){}
                5.7.1Thread内部声明的三个优先级常量   
    public static final int MIN_PRIORITY = 1;
    public static final int NORM_PRIORITY = 5;//default
    public static final int MAX_PRIORITY = 10;
6. 线程的生命周期
        6.1 JDK5线程的生命周期

        6.2 JDK17线程的生命周期
public enum State {
        NEW,
        RUNNABLE,
        BLOCKED,
        WAITING,
        TIMED_WAITING,
        TERMINATED;
    }

          

7.多线程安全问题

        例如卖票超卖。

/**
 * 多线程出现的问题
 */
public class SaleTicket implements Runnable{

    private static int ticket = 100;
    @Override
    public void run() {

        while (true){
           if(ticket > 0){
               System.out.println(Thread.currentThread().getName() +"卖了第" + ticket + "张票");
               ticket--;
           }else {
               break;
           }
        }
    }
    public static void main(String[] args) {

        Runnable saleTicket = new SaleTicket();
        Thread window1 = new Thread(saleTicket);
        Thread window2 = new Thread(saleTicket);
        Thread window3 = new Thread(saleTicket);

        window1.start();
        window2.start();
        window3.start();
    }
}

        结果：导致重复卖票

Thread-0卖了第100张票
Thread-1卖了第100张票
Thread-2卖了第100张票
Thread-1卖了第98张票
Thread-0卖了第99张票

        原因：操作不是原子操作

        解决办法：java同步机制

8.java同步机制

        同步代码块：

                synchronized (锁){ // 需要被同步的代码; }

                锁可以使用this或者类.class，但必须保证多个线程使用同一把锁。

                需要被同步的代码即是对共享资源的操作。

        使用同步代码块解决问题：

public class SyncSaleTicket implements Runnable {

    private static int ticket = 100;
    @Override
    public void run() {

        while (true){
            synchronized (this) {
                if(ticket > 0){
                    System.out.println(Thread.currentThread().getName() +"卖了第" + ticket + "张票");
                    ticket--;
                    try {
                        Thread.sleep(100);
                    } catch (InterruptedException e) {
                        throw new RuntimeException(e);
                    }
                }else {
                    break;
                }
            }
        }
    }
    public static void main(String[] args) {

        Runnable saleTicket = new SyncSaleTicket();
        Thread window1 = new Thread(saleTicket);
        Thread window2 = new Thread(saleTicket);
        Thread window3 = new Thread(saleTicket);

        window1.start();
        window2.start();
        window3.start();
    }

}

        结果：没有超卖现象

Thread-0卖了第100张票
Thread-2卖了第99张票
Thread-1卖了第98张票
Thread-2卖了第97张票

        使用同步方法：

        非静态同步方法的锁是this，静态同步方法的锁是当前类.class，考虑方法是否非静态来保证多个线程使用同一把锁。

public class SyncMethodSaleTicket implements Runnable {

    private static int ticket = 100;
    private static boolean flag = true;
    @Override
    public void run() {
        while (flag){
            sale();
        }

    }
    public synchronized void sale() {
        if(ticket > 0){
            System.out.println(Thread.currentThread().getName() +"卖了第" + ticket + "张票");
            ticket--;
            try {
                Thread.sleep(100);
            } catch (InterruptedException e) {
                throw new RuntimeException(e);
            }
        }else {
            flag = false;
        }
    }
    public static void main(String[] args) {

        Runnable saleTicket = new SyncMethodSaleTicket();
        Thread window1 = new Thread(saleTicket);
        Thread window2 = new Thread(saleTicket);
        Thread window3 = new Thread(saleTicket);

        window1.start();
        window2.start();
        window3.start();
    }

}

        synchronized的好处和弊端

                synchronized解决了线程的安全问题，但是synchronized是串行化执行的，相对无锁结构效率比较低。

9.单例之饿汉式
public class Singleton {
    
    //避免指令重拍
    private static volatile Singleton singleton ;

    private Singleton(){}

    public static Singleton getInstance(){
        if (singleton == null) {
            synchronized (Singleton.class) {
                if (singleton == null) {
                    singleton = new Singleton();
                }
            }
        }
        return singleton;
    }

    public static void main(String[] args) {
        Singleton instance1 = Singleton.getInstance();
        Singleton instance2 = Singleton.getInstance();
        System.out.println(instance1 == instance2);
    }
}
10.线程死锁

        不同的线程分别占用对方需要的同步资源不放弃，都在等待对方放弃 自己需要的同步资源，就形成了线程的死锁。

        死锁的案例：

public class DeathLock {

    private static final Object obj1 = new Object();
    private static final Object obj2 = new Object();

    public static void main(String[] args) {

        Thread thread1 = new Thread(new Runnable() {
            @Override
            public void run() {
                System.out.println(Thread.currentThread().getName() + "开始执行");
                synchronized (obj1) {
                    try {
                        Thread.sleep(3000);
                    } catch (InterruptedException e) {
                        throw new RuntimeException(e);
                    }
                    System.out.println(Thread.currentThread().getName() + "持有资源obj1,希望得到资源obj2");
                    synchronized (obj2) {
                        System.out.println(Thread.currentThread().getName() + "得到资源obj2");
                    }
                }
            }
        });
        Thread thread2 = new Thread(new Runnable() {
            @Override
            public void run() {
                System.out.println(Thread.currentThread().getName() + "开始执行");
                synchronized (obj2) {
                    try {
                        Thread.sleep(3000);
                    } catch (InterruptedException e) {
                        throw new RuntimeException(e);
                    }
                    System.out.println(Thread.currentThread().getName() + "持有资源obj2,希望得到资源obj1");
                    synchronized (obj1) {
                        System.out.println(Thread.currentThread().getName() + "得到资源obj1");
                    }
                }
            }
        });
        thread1.start();
        thread2.start();
        System.out.println("方法结束.....");
    }
}

        结果：可以看出Thread-1得不到obj1，Thread-0得不到obj2，处在一个僵持的状态。

方法结束.....
Thread-1开始执行
Thread-0开始执行
Thread-1持有资源obj2,希望得到资源obj1
Thread-0持有资源obj1,希望得到资源obj2

        诱发死锁的原因：

                互斥条件、占用且等待、不可抢夺、循环等待。

        解决死锁：

  1. 互斥条件无法被破坏，因为线程需要互斥解决安全问题。
  2. 可以考虑一次性申请所需要的资源，这样就不存在等待问题。
  3. 占用资源的线程在申请其他资源的时候，如果申请不到，就考虑放弃已经占有的资源。
  4. 可以将资源改为线性顺序，申请资源的时候先申请序号较小的，这样避免循环等待的问题。
11. Lock

        从JDK 5.0开始，Java提供的显式定义同步锁，在java.util.concurrent.locks包下的接口，需要确保多线程使用同一个Lock，需要声明为static final。

package java.util.concurrent.locks;
public interface Lock {}
public class LockSaleTicket implements Runnable {

    private static int ticket = 100;
    private static boolean flag = true;
    private static final Lock lock = new ReentrantLock();
    @Override
    public void run() {
        while (flag){
            sale();
        }
    }
    public void sale() {
        lock.lock();
        if(ticket > 0){
            System.out.println(Thread.currentThread().getName() +"卖了第" + ticket + "张票");
            ticket--;
            try {
                Thread.sleep(100);
            } catch (InterruptedException e) {
                throw new RuntimeException(e);
            }
        }else {
            flag = false;
        }
        lock.unlock();
    }
    public static void main(String[] args) {

        Runnable saleTicket = new LockSaleTicket();
        Thread window1 = new Thread(saleTicket);
        Thread window2 = new Thread(saleTicket);
        Thread window3 = new Thread(saleTicket);

        window1.start();
        window2.start();
        window3.start();
    }
}
  12.synchronized 与Lock 的对比  

        优先使用顺序：

                Lock——>同步代码块（已经进入了方法体，分配了相应资源）——> 同步方法 （在方法体之外）。

  1. Lock是显式锁（手动开启和关闭锁，别忘记关闭锁），synchronized是 隐式锁，出了作用域自动释放。
  2. Lock只有代码块锁，synchronized有代码块锁和方法锁。
  3. 使用Lock锁，JVM将花费较少的时间来调度线程，性能更好。并且具有 更好的扩展性（提供更多的子类）
13.线程通信

        线程通信是指线程利用wait() 与notify() 和notifyAll()进行一个协调合作，以上都是object的方法，此三个方法都要在同步代码块中使用，调用者而必须是同步监视器。

        例如交替打印1-100。

public class PrintNumber implements Runnable {

    private static int num = 1;
    @Override
    public void run() {

        while (true){
            synchronized (this) {
                this.notifyAll();
                if(num <= 100){
                    System.out.println(Thread.currentThread().getName() +"打印了" + num );
                    num++;
                    try {
                        this.wait();
                    } catch (InterruptedException e) {
                        throw new RuntimeException(e);
                    }
                }else {
                    break;
                }
            }
        }
    }
    public static void main(String[] args) {

        Runnable saleTicket = new PrintNumber();
        Thread window1 = new Thread(saleTicket);
        Thread window2 = new Thread(saleTicket);

        window1.start();
        window2.start();
    }

}

        结果 ：

Thread-0打印了1
Thread-1打印了2
Thread-0打印了3
Thread-1打印了4
Thread-0打印了5
Thread-1打印了6
14.sleep 和 wait 的区别
  1. sleep是Thread的一个静态方法，wait是Object的一个方法。
  2. sleep和wait调用后都会进入阻塞状态
  3. sleep不会释放锁资源，wait会释放锁资源进入等待池中。
15. 线程池

        提前创建好多个线程，放入线程池中，使用时直接获取，使用完放回池中.

        好处：

  1. 提高响应速度（减少了创建新线程的时间）。
  2. 降低资源消耗（重复利用线程池中线程，不需要每次都创建）。
  3. 便于线程管理。

        线程池的使用：

        

public class ThreadPool {

    private static final ExecutorService service = Executors.newFixedThreadPool(10);
    public static void main(String[] args) {
        Runnable runnable1 = new Runnable() {
            @Override
            public void run() {
                System.out.println("runnable .... 1");
            }
        };
        Runnable runnable2 = new Runnable() {
            @Override
            public void run() {
                System.out.println("runnable .... 2");
            }
        };
        service.execute(runnable1);
        service.execute(runnable2);
        System.out.println("main ....");
        service.shutdown();
    }
}
        15. 1线程池的核心创建

        依次为核心线程数、最大线程数、存活时间、存活时间单位、队列、线程工厂、拒绝策略

    public ThreadPoolExecutor(int corePoolSize,
                              int maximumPoolSize,
                              long keepAliveTime,
                              TimeUnit unit,
                              BlockingQueue<Runnable> workQueue,
                              ThreadFactory threadFactory,
                              RejectedExecutionHandler handler) {}

cancanneedmaomao
关注
  • 1
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
Java基础之多线程
08-26
以下是我们Java基础多线程的一些知识点总结，看完以后会觉得多线程也可以这么简单，小编精心推荐，希望能对大家有所帮助
Java基础之多线程.md
11-10
Java多线程，Java基础，并发
java基础之多线程的引入
weixin_50691399的博客
11-03 2470
本文主要是引入多线程
Java基础——多线程详解！！！！
qq_52519008的博客
10-04 4629
就是进程中的一个独立控制单元，线程在控制着进程的执行。一个进程中至少有一个进程。多线程是多任务的一种特别的形式，但多线程使用了更小的资源开销。多线程能满足程序员编写高效率的程序来达到充分利用 CPU 的目的。注意：很多多线程是模拟出来的，真正的多线程是指有多个CPU，即多核，如服务器。如果是模拟出来的多线程，即在一个CPU的情况下，在同一个时间点，CPU只执行一个代码，因为切换得很快，所以就有同时执行的错觉。程序、进程和线程的大家可以通过百度搜索得知，在这里我就不多阐述。
Java 多线程编程基础(详细)
一夜星尘
11-03 3万+
Java多线程编程基础进程与线程多线程实现Thread类实现多线程Runnable接口实现多线程Callable接口实现多线程多线程运行状态多线程常用操作方法线程的命名和获取线程休眠线程中断线程强制执行线程让步线程优先级设定线程的同步和锁死线程同步处理线程死锁 进程与线程 进程与线程的基本认识 进程（Process）：进程是程序的一次动态执行过程，它经历了从代码加载、执行、到执行完毕的一个完整过程；同时也是并发执行的程序在执行过程中分配和管理资源的基本单位，竞争计算机系统资源的基本单位。 线程（Thread
Java面试之多线程篇
qq_24095055的博客
03-14 3293
Java面试之多线程篇 篇章 个人博客链接 多线程基础
java多线程（超详细）
zdl66的博客
08-14 9万+
进程就是正在运行中的程序（进程是驻留在内存中的）是系统执行资源分配和调度的独立单位每一进程都有属于自己的存储空间和系统资源注意：进程A和进程B的内存独立不共享。
Java多线程（超详细！）
热门推荐
一只小菜鸡
05-13 12万+
1、什么是进程？什么是线程？ 进程是:一个应用程序（1个进程是一个软件）。 线程是：一个进程中的执行场景/执行单元。 注意：一个进程可以启动多个线程。 eg.对于java程序来说，当在DOS命令窗口中输入： java HelloWorld 回车之后。 会先启动JVM，而JVM就是一个进程。 JVM再启动一个主线程调用main方法。 同时再启动一个垃圾回收线程负责看护，回收垃圾。 最起码，现在的java程序中至少有两个线程并发， 一个是垃圾回收线程，一个是执行main方法的主线程。 3、进程和线程是什么关系？
Java基础之——Java 线程
前尘忆梦的博客
02-03 4745
Java 线程 1、创建线程类（方法一） Java使用 java.lang.Thread 类代表线程，所有的线程对象都必须是 Thread 类或其子类的实例。每个线程的作用是完成一定的任务，实际上就是执行一段程序流即一段顺序执行的代码。Java 使用线程执行体来代表这段程序流。 Java 中通过继承 Thread 类来创建并启动多线程的步骤如下： 定义 Thread 类的子类，并重写该类的 run() 方法，该 run() 方法的方法体就代表了线程需要完成的任务，因此把 run() 方法称为线程执行体。
Java基础进阶多线程概述
qq_46096136的博客
09-11 6353
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 Web基础篇之Java多线程
聚沙成塔
05-08 5433
1、多线程与进程 1.1、是什么? 线程有时被称为轻量进程(Lightweight Process，LWP），是程序执行流的最小单元，进程与线程区别如下：一个进程至少有一个线程.。 1.2、扩展： 进程与线程区别，线程的划分尺度小于进程，使得多线程程序的并发性高。 另外，进程在执行过程中拥有独立的内存单元，而多个线程共享内存，从而极大地提高了程序的运行效率。 线程在执行过程中与进程还是有区别的。每...
java基础之多线程讲解
04-09
java基础之多线程讲解
Java基础多线程.xmind
09-20
个人关于java基础多线程的思维导图总结。0积分下载。如果认为有帮助，请关注点赞，日后还有更多免费资源。
JAVA之多线程（基础图）
02-20
JAVA之多线程（基础图）
进阶2 探索图形化编程：扩展图形组件与切片开发的魅力
优树搭的博客
05-30 1285
当这些切片成功地通过图形程序串联起来后，在后续进行程序升级或维护时，大家会惊喜地发现，图形程序就如同清晰的路标一般，可以非常便捷地通过图形程序准确地定位到相关切片，并对这些切片进行在线查看、编辑和执行等操作。而且，这些切片的代码长度通常不会太长，相比传统开发的代码，阅读起来要容易得多，这无疑会给系统后续的工作带来极大的便利。
operator ＜=＞ (spaceship operator)
janeqi1987的专栏
05-28 855
= 与!= 操作符为了检查是否相等，现在定义== 操作符就够了。当编译器找不到表达式的匹配声明a!=b 时，编译器会重写表达式并查找!(a==b)。若这不起作用，编译器也会尝试改变操作数的顺序，所以也会尝试!(b==a):a!=b,!(b==a)因此，对于TypeA 的a 和TypeB 的b，编译器将能够识别并编译a!= b若需要的话，可以这样做• 一个独立函数operator!• 一个独立函数operator==(TypeA, TypeB)
Spring6基础笔记
质胜文则野，文胜质则史。文质彬彬，然后君子。
05-21 1188
Spring 是一款主流的 Java EE 轻量级开源框架 ，Spring 由“Spring 之父”Rod Johnson 提出并创立，其目的是用于简化 Java 企业级应用的开发难度和开发周期。Spring的用途不仅限于服务器端的开发。从简单性、可测试性和松耦合的角度而言，任何Java应用都可以从Spring中受益。Spring 框架除了自己提供功能外，还提供整合其他技术和框架的能力。Spring 自诞生以来备受青睐，一直被广大开发人员作为 Java 企业级应用程序开发的首选。时至今日，Spring 俨然
Java 异常处理中try-catch块、finally子句以及自定义异常的使用
最新发布
Itmastergo的博客
05-31 480
异常是程序运行过程中出现的非正常情况。Java 使用异常类（Exception 类及其子类）来表示这些异常情况。异常处理的核心思想是将正常的程序流程与异常处理流程分离开来，使代码更加清晰和可维护。Throwable 类：所有异常和错误的基类。Error 类：表示系统级的错误，程序通常无法处理，比如内存不足（OutOfMemoryError）。Exception 类：表示程序中可以处理的异常情况。RuntimeException 类。
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、付费专栏及课程。

余额充值