第八章 多线程

最新推荐文章于 2023-03-08 16:27:34 发布
最新推荐文章于 2023-03-08 16:27:34 发布
阅读量64 收藏
点赞数
分类专栏： Java 文章标签： java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_41206153/article/details/123782922
版权

1、基本概念

在这里插入图片描述
多线程的优点：
在这里插入图片描述
何时需要多线程？
在这里插入图片描述

2、多线程的创建和使用

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

2.1 方式一：继承Thread类

在这里插入图片描述

package com.atguigu.java;

/**
 * 多线程的创建，方式一：继承于Thread类
 * 1、创建一个继承于Thread类的子类。
 * 2、重写Thread类的run()
 * 3、创建Thread类的子类的对象
 * 4、通过此对象调用start()
 *
 * 例子：遍历100以内的所有的偶数
 *
 * @author bjk
 * @create 2021-08-28 14:21
 */

//1、创建一个继承于Thread类的子类

class MyThread extends Thread{
    //2、重写Thread类的run() -->将此线程执行的操作声明在run()中
    @Override
    public void run() {
        for (int i = 0; i < 100; i++) {
            if(i % 2 == 0){
                System.out.println(i);
            }
        }
    }
}

public class ThreadTest {
    public static void main(String[] args) {
        //3、创建Thread类的子类的对象
        MyThread t1 = new MyThread();

        //4、通过此对象调用start():①启动当前线程②调用当前线程的run()
        t1.start();
        for (int i = 0; i < 100; i++) {
            if(i % 2 == 0){
                System.out.println(i + "********main()**********");
            }
        }
    }
}

常用方法：
在这里插入图片描述
线程的调度：
在这里插入图片描述
线程的优先级：
在这里插入图片描述
线程的分类：
在这里插入图片描述

2.2 方式二：实现Runnable接口

在这里插入图片描述

package com.atguigu.java;

/**
 * 创建多线程的方式二：实现Runnable接口
 * 1. 创建一个实现Runnable接口的类。
 * 2. 实现类去实现Runnable中的抽象方法：run()
 * 3. 创建实现类的对象。
 * 4. 将此对象作为参数传递到Thread类的构造器中，创建Thread类的对象。
 * 5. 通过Thread类的对象调用strat()
 *
 * @author bjk
 * @create 2021-08-28 17:08
 */
//1. 创建一个实现Runnable接口的类。
class MThread implements Runnable{

    //2. 实现类去实现Runnable中的抽象方法：run()
    @Override
    public void run() {
        for (int i = 0; i < 100; i++) {
            if(i % 2 == 0){
                System.out.println(Thread.currentThread().getName() + ":" +i);
            }
        }
    }
}
public class ThreadTest1 {
    public static void main(String[] args) {
        //3. 创建实现类的对象。
        MThread mThread = new MThread();
        //4. 将此对象作为参数传递到Thread类的构造器中，创建Thread类的对象。
        Thread t1 = new Thread(mThread);
        //5. 通过Thread类的对象调用strat()
        t1.start();

        //再启动一个线程，遍历100以内的偶数
        Thread t2 = new Thread(mThread);
        t2.start();
    }
}

两种方式的对比：
在这里插入图片描述

3、线程的生命周期

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

4、线程的同步

问题的提出
  • 多个线程执行的不确定性引起执行结果的不稳定。
  • 多个线程对账本的共享，会造成操作的不完整性，会破坏数据。
package com.atguigu.java;

/**
 * 例子：创建三个窗口卖票，总票数为100张.使用实现Runnable接口的方式
 *
 * 1.问题：卖票过程中，出现了重票、错票 -->出现了线程的安全问题
 * 2.问题出现的原因：当某个线程操作车票的过程中，尚未操作完成时，其他线程参与进来，也操作车票。
 * 3.如何解决：当一个线程a在操作ticket的时候，其他线程不能参与进来。直到线程a操作完ticket时，其他
 *            线程才可以开始操作ticket。这种情况即使线程a出现了阻塞，也不能被改变。
 *
 * 4.在Java中，我们通过同步机制，来解决线程的安全问题。
 *
 *  方式一：同步代码块
 *
 *   synchronized(同步监视器){
 *      //需要被同步的代码
 *
 *   }
 *  说明：1.操作共享数据的代码，即为需要被同步的代码。  -->不能包含代码多了，也不能包含代码少了。
 *       2.共享数据：多个线程共同操作的变量。比如：ticket就是共享数据。
 *       3.同步监视器，俗称：锁。任何一个类的对象，都可以充当锁。
 *          要求：多个线程必须要共用同一把锁。
 *
 *       补充：在实现Runnable接口创建多线程的方式中，我们可以考虑使用this充当同步监视器。
 *  方式二：同步方法。
 *     如果操作共享数据的代码完整的声明在一个方法中，我们不妨将此方法声明同步的。
 *
 *
 *  5.同步的方式，解决了线程的安全问题。---好处
 *    操作同步代码时，只能有一个线程参与，其他线程等待。相当于是一个单线程的过程，效率低。 ---局限性
 *
 * @author shkstart
 * @create 2019-02-13 下午 4:47
 */
class Window1 implements Runnable{

    private int ticket = 100;
    //    Object obj = new Object();
//    Dog dog = new Dog();
    @Override
    public void run() {
//        Object obj = new Object();
        while(true){
            synchronized (this){//此时的this:唯一的Window1的对象   //方式二：synchronized (dog) {

                if (ticket > 0) {

                    try {
                        Thread.sleep(100);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }

                    System.out.println(Thread.currentThread().getName() + ":卖票，票号为：" + ticket);


                    ticket--;
                } else {
                    break;
                }
            }
        }
    }
}

public class WindowTest1 {
    public static void main(String[] args) {
        Window1 w = new Window1();

        Thread t1 = new Thread(w);
        Thread t2 = new Thread(w);
        Thread t3 = new Thread(w);

        t1.setName("窗口1");
        t2.setName("窗口2");
        t3.setName("窗口3");

        t1.start();
        t2.start();
        t3.start();
    }

}

class Dog{

}

package com.atguigu.java;

/**
 * 使用同步代码块解决继承Thread类的方式的线程安全问题
 *
 * 例子：创建三个窗口卖票，总票数为100张.使用继承Thread类的方式
 *
 * 说明：在继承Thread类创建多线程的方式中，慎用this充当同步监视器，考虑使用当前类充当同步监视器。
 *
 * @author bjk
 * @create 2022-02-25-13:23
 */

class Window2 extends Thread{

    private static int ticket = 100;

    private static Object obj = new Object();

    @Override
    public void run() {

        while(true){
            //正确的
//            synchronized (obj){
            synchronized (Window2.class){//Class clazz = Window2.class,Window2.class只会加载一次
                //错误的方式：this代表着t1,t2,t3三个对象
//              synchronized (this){

                if(ticket > 0){

                    try {
                        Thread.sleep(100);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }

                    System.out.println(getName() + "：卖票，票号为：" + ticket);
                    ticket--;
                }else{
                    break;
                }
            }

        }

    }
}

public class WindowTest2 {
    public static void main(String[] args) {
        Window2 t1 = new Window2();
        Window2 t2 = new Window2();
        Window2 t3 = new Window2();


        t1.setName("窗口1");
        t2.setName("窗口2");
        t3.setName("窗口3");

        t1.start();
        t2.start();
        t3.start();

    }
}

package com.atguigu.java;

/**
 * *使用同步方法解决实现Runnable接口的线程安全问题
 *
 *  关于同步方法的总结：
 *  1. 同步方法仍然涉及到同步监视器，只是不需要我们显式的声明。
 *  2. 非静态的同步方法，同步监视器是：this
 *     静态的同步方法，同步监视器是：当前类本身
 *
 * @author bjk
 * @create 2022-02-25-13:55
 */
class Window3 implements Runnable {

    private int ticket = 100;

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

            show();
        }
    }

    private synchronized void show(){//同步监视器：this
        //synchronized (this){

        if (ticket > 0) {

            try {
                Thread.sleep(100);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }

            System.out.println(Thread.currentThread().getName() + ":卖票，票号为：" + ticket);

            ticket--;
        }
        //}
    }
}


public class WindowTest3 {
    public static void main(String[] args) {
        Window3 w = new Window3();

        Thread t1 = new Thread(w);
        Thread t2 = new Thread(w);
        Thread t3 = new Thread(w);

        t1.setName("窗口1");
        t2.setName("窗口2");
        t3.setName("窗口3");

        t1.start();
        t2.start();
        t3.start();
    }

}

package com.atguigu.java;

/**
 *
 * 使用同步方法处理继承Thread类的方式中的线程安全问题
 * @author bjk
 * @create 2022-02-25-14:00
 */
class Window4 extends Thread {


    private static int ticket = 100;

    @Override
    public void run() {

        while (true) {

            show();
        }

    }
    private static synchronized void show(){//同步监视器：Window4.class
        //private synchronized void show(){ //同步监视器：t1,t2,t3。此种解决方式是错误的
        if (ticket > 0) {

            try {
                Thread.sleep(100);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }

            System.out.println(Thread.currentThread().getName() + "：卖票，票号为：" + ticket);
            ticket--;
        }
    }
}


public class WindowTest4 {
    public static void main(String[] args) {
        Window4 t1 = new Window4();
        Window4 t2 = new Window4();
        Window4 t3 = new Window4();


        t1.setName("窗口1");
        t2.setName("窗口2");
        t3.setName("窗口3");

        t1.start();
        t2.start();
        t3.start();

    }
}

在这里插入图片描述

同步的范围

  1. 如何找问题，即代码是否存在线程安全？
  • 明确哪些代码是多线程运行的代码
  • 明确多个线程是否有共享数据
  • 明确多个线程运行代码中是否有多条语句操作共享数据
  1. 如何解决呢？
  • 对多条操作共享数据的语句，只能让一个线程都执行完，在执行过程中，其他线程不可以参与执行。即所有操作共享数据的这些语句都要放在同步范围内。
  1. 切记：
    • 范围太小：没锁住所有有安全问题的代码。
    • 范围太大：没发挥多线程的功能。

释放锁的操作

  • 当前线程的同步方法、同步代码块执行结束。
  • 当前线程在同步代码块、同步方法中遇到break、return终止了该代码块、该方法的继续执行。
  • 当前线程在同步代码块、同步方法中出现了未处理的Error或Exception，导致异常结束。
  • 当前线程在同步代码块、同步方法中执行了线程对象的**wait()**方法，当前线程暂停，并释放锁。

不会释放锁的操作

  • 线程执行同步代码块或同步方法时，程序调用Thread.sleep()、Thread.yield()方法暂停当前线程的执行
  • 线程执行同步代码块时，其他线程调用了该线程的suspend()方法将该线程挂起，该线程不会释放锁（同步监视器）。
    • 应尽量避免使用suspend()和resume()来控制线程

线程的死锁问题

  • 死锁
    • 不同的线程分别占用对方需要的同步资源不放弃，都在等待对方放弃自己需要的同步资源，就形成了线程的死锁。
    • 出现死锁后，不会出现异常，不会出现提示，只是所有的线程都处于阻塞状态，无法继续。
  • 解决方法
    • 专门的算法、原则
    • 尽量减少同步资源的定义
    • 尽量避免嵌套同步

Lock（锁）

  • 从JDK 5.0开始，Java提供了更强大的线程同步机制——通过显式定义同步锁对象来实现同步。同步锁使用Lock对象充当。
  • java.util.concurrent.locks.Lock接口是控制多个线程对共享资源进行访问的工具。锁提供了对共享资源的独占访问，每次只能有一个线程对Lock对象加锁，线程开始访问共享资源之前应先获得Lock对象。
  • ReentrantLock 类实现了 Lock ，它拥有与 synchronized 相同的并发性和内存语义，在实现线程安全的控制中，比较常用的是ReentrantLock，可以显式加锁、释放锁。
class A{
    private final ReentrantLock lock = new ReenTrantLock();
    public void m(){
        lock.lock();
        try{
            //保证线程安全的代码
        }
        finally{
            lock.unlock();
        }
    }
}

package com.atguigu.java;

import java.util.concurrent.locks.ReentrantLock;

/**
 * 解决线程安全问题的方式三：Lock锁  --- JDK5.0新增
 *
 * 1. 面试题：synchronized 与 Lock的异同？
 *   相同：二者都可以解决线程安全问题
 *   不同：synchronized机制在执行完相应的同步代码以后，自动的释放同步监视器
 *        Lock需要手动的启动同步（lock()），同时结束同步也需要手动的实现（unlock()）
 *
 * 2.优先使用顺序：
 * Lock --- 同步代码块（已经进入了方法体，分配了相应资源） --- 同步方法（在方法体之外）
 *
 *
 *  面试题：如何解决线程安全问题？有几种方式
 *
 * @author bjk
 * @create 2022-02-25-14:50
 */
class Window implements Runnable{

    private int ticket = 100;
    //1.实例化ReentrantLock
    private ReentrantLock lock = new ReentrantLock();

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

                //2.调用锁定方法lock()
                lock.lock();

                if(ticket > 0){

                    try {
                        Thread.sleep(100);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }

                    System.out.println(Thread.currentThread().getName() + "：售票，票号为：" + ticket);
                    ticket--;
                }else{
                    break;
                }
            }finally {
                //3.调用解锁方法：unlock()
                lock.unlock();
            }

        }
    }
}

public class LockTest {
    public static void main(String[] args) {
        Window w = new Window();

        Thread t1 = new Thread(w);
        Thread t2 = new Thread(w);
        Thread t3 = new Thread(w);

        t1.setName("窗口1");
        t2.setName("窗口2");
        t3.setName("窗口3");

        t1.start();
        t2.start();
        t3.start();
    }
}

5、线程的通信

  1. wait() 与 notify() 和 notifyAll()
  • wait()：令当前线程挂起并放弃CPU、同步资源并等待，使别的线程可访问并修改共享资源，而当前线程排队等候其他线程调用notify()或notifyAll()方法唤醒，唤醒后等待重新获得对监视器的所有权后才能继续执行。
  • notify()：唤醒正在排队等待同步资源的线程中优先级最高者结束等待
  • notifyAll ()：唤醒正在排队等待资源的所有线程结束等待.

  1. 这三个方法只有在synchronized方法或synchronized代码块中才能使用，否则会报java.lang.IllegalMonitorStateException异常。

  2. 因为这三个方法必须有锁对象调用，而任意对象都可以作为synchronized的同步锁，因此这三个方法只能在Object类中声明。

wait() 方法
  • 在当前线程中调用方法： 对象名.wait()。
  • 使当前线程进入等待（某对象）状态 ，直到另一线程对该对象发出 notify (或notifyAll) 为止。
  • 调用方法的必要条件：当前线程必须具有对该对象的监控权（加锁）。
  • 调用此方法后，当前线程将释放对象监控权 ，然后进入等待。
  • 在当前线程被notify后，要重新获得监控权，然后从断点处继续代码的执行。
**notify()/notifyAll()**方法
  • 在当前线程中调用方法： 对象名.notify()
  • 功能：唤醒等待该对象监控权的一个/所有线程。
  • 调用方法的必要条件：当前线程必须具有对该对象的监控权（加锁）

6、JDK5.0新增线程创建方式

新增方式一：实现Callable接口
  • 与使用Runnable相比， Callable功能更强大些
    • 相比run()方法，可以有返回值
    • 方法可以抛出异常
    • 支持泛型的返回值
    • 需要借助FutureTask类，比如获取返回结果
  • Future接口
    • 可以对具体Runnable、Callable任务的执行结果进行取消、查询是否完成、获取结果等。
    • FutrueTask是Futrue接口的唯一的实现类
    • FutureTask 同时实现了Runnable, Future接口。它既可以作为Runnable被线程执行，又可以作为Future得到Callable的返回值。
package com.atguigu.java;

import java.util.concurrent.Callable;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.FutureTask;

/**
 *
 * 创建线程的方式三：实现Callable接口。 --- JDK 5.0新增
 *
 * 如何理解实现Callable接口的方式创建多线程比实现Runnable接口创建多线程方式强大？
 * 1. call()可以有返回值的。
 * 2. call()可以抛出异常，被外面的操作捕获，获取异常的信息
 * 3. Callable是支持泛型的
 *
 * @author bjk
 * @create 2022-02-25-16:52
 */
//1.创建一个实现Callable的实现类
class NumThread implements Callable {
    //2.实现call方法，将此线程需要执行的操作声明在call()中
    @Override
    public Object call() throws Exception {
        int sum = 0;
        for (int i = 1; i <= 100; i++) {
            if(i % 2 == 0){
                System.out.println(i);
                sum += i;
            }
        }
        return sum;
    }
}


public class ThreadNew {
    public static void main(String[] args) {
        //3.创建Callable接口实现类的对象
        NumThread numThread = new NumThread();
        //4.将此Callable接口实现类的对象作为传递到FutureTask构造器中，创建FutureTask的对象
        FutureTask futureTask = new FutureTask(numThread);
        //5.将FutureTask的对象作为参数传递到Thread类的构造器中，创建Thread对象，并调用start()
        new Thread(futureTask).start();

        try {
            //6.获取Callable中call方法的返回值
            //get()返回值即为FutureTask构造器参数Callable实现类重写的call()的返回值。
            Object sum = futureTask.get();
            System.out.println("总和为：" + sum);
        } catch (InterruptedException e) {
            e.printStackTrace();
        } catch (ExecutionException e) {
            e.printStackTrace();
        }
    }

}
新增方式二：使用线程池
  • **背景：**经常创建和销毁、使用量特别大的资源，比如并发情况下的线程，对性能影响很大。
  • **思路：**提前创建好多个线程，放入线程池中，使用时直接获取，使用完放回池中。可以避免频繁创建销毁、实现重复利用。类似生活中的公共交通工具。
  • 好处：
    • 提高响应速度（减少了创建新线程的时间）
    • 降低资源消耗（重复利用线程池中线程，不需要每次都创建）
    • 便于线程管理
      • corePoolSize：核心池的大小
      • maximumPoolSize：最大线程数
      • keepAliveTime：线程没有任务时最多保持多长时间后会终止
      • …
        线程池相关API：
  • JDK 5.0起提供了线程池相关API：ExecutorService 和 Executors
  • ExecutorService：真正的线程池接口。常见子类ThreadPoolExecutor
    • void execute(Runnable command) ：执行任务/命令，没有返回值，一般用来执行Runnable
    • Future submit(Callable task)：执行任务，有返回值，一般又来执行Callable
    • void shutdown() ：关闭连接池
  • Executors：工具类、线程池的工厂类，用于创建并返回不同类型的线程池
    • Executors.newCachedThreadPool()：创建一个可根据需要创建新线程的线程池
    • Executors.newFixedThreadPool(n); 创建一个可重用固定线程数的线程池
    • Executors.newSingleThreadExecutor() ：创建一个只有一个线程的线程池
    • Executors.newScheduledThreadPool(n)：创建一个线程池，它可安排在给定延迟后运行命令或者定期地执行。
package com.atguigu.java;

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

/**
 *
 * 创建线程的方式四：使用线程池
 *
 * 好处：
 * 1.提高响应速度（减少了创建新线程的时间）
 * 2.降低资源消耗（重复利用线程池中线程，不需要每次都创建）
 * 3.便于线程管理
 *      corePoolSize：核心池的大小
 *      maximumPoolSize：最大线程数
 *      keepAliveTime：线程没有任务时最多保持多长时间后会终止
 *
 *
 * 面试题：创建多线程有几种方式？四种！
 * @author bjk
 * @create 2022-02-25-19:36
 */
class NumberThread implements Runnable{

    @Override
    public void run() {
        for(int i = 0;i <= 100;i++){
            if(i % 2 == 0){
                System.out.println(Thread.currentThread().getName() + ": " + i);
            }
        }
    }
}

class NumberThread1 implements Runnable{

    @Override
    public void run() {
        for(int i = 0;i <= 100;i++){
            if(i % 2 != 0){
                System.out.println(Thread.currentThread().getName() + ": " + i);
            }
        }
    }
}

public class ThreadPool {

    public static void main(String[] args) {
        //1. 提供指定线程数量的线程池
        ExecutorService service = Executors.newFixedThreadPool(10);
        ThreadPoolExecutor service1 = (ThreadPoolExecutor) service;
        //设置线程池的属性
//        System.out.println(service.getClass());
//        service1.setCorePoolSize(15);
//        service1.setKeepAliveTime();

        //2.执行指定的线程的操作。需要提供实现Runnable接口或Callable接口实现类的对象
        service.execute(new NumberThread());//适合适用于Runnable
        service.execute(new NumberThread1());//适合适用于Runnable

//        service.submit(Callable callable);//适合使用于Callable
        //3.关闭连接池
        service.shutdown();
    }
}
bjkiss
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
java基础案例教程——第八章 多线程
W6666612的博客
08-25 499
多线程
Java多线程下(线程的同步(synchronized&lock用法以及区别)、死锁问题的引入以及避免以及线程的通信(生产者、消费者问题))
斗鹰的技术专栏
09-26 259
上一篇文章：Java多线程上(线程的四种创建方式以及比较、线程的调度和线程的生命周期) 那么继续说说线程的同步吧。 首先说一个生活中处处可见的案例。 模拟火车站售票程序，开启三个窗口售票。 public class Ticket implements Runnable{ private int tick = 100; public void run() { while(tru...
Java高级-多线程编程
Achilles的博客
09-13 200
多线程的创建，方式一：继承于Thread类 1. 创建一个继承于Thread类的子类 2. 重写Thread类的run() -->将此线程执行的操作声明在run()中 3. 创建Thread类的子类的对象 4. 通过此对象调用start() 例子：遍历100以内的所有的偶数 // 1. 创建一个继承于Thread类的子类 class MyThread extends Thread { // 2. 重写Thread类的run() @Override public voi.
Java之多线程
weixin_52875557的博客
08-15 214
线程4种创建的方式，线程池的用法和各项参数，synchroized关键字互斥锁
Java多线程基础（一）---线程安全（synchronized 反编译深入分析,JConsole监控进程运行，程序死锁信息打印）
康师傅没有眼泪
06-06 474
1 学习内容 synchronized关键字介绍 synchronized和Intrinsic Locks 关系 synchronized用法和注意的问题 程序死锁 总结 2 具体内容 在串行化的任务执行中，由于不存在资源的共享，线程安全问题当然不用考虑，但是串行化的任务执行效率低下，让人忍无可忍。多线程的执行任务应用而生，同时多线程的引入也带来了共享资源的安全问题。 什么是共享资源？...
第8章 多线程.pptx
12-29
在标题提到的“第8章 多线程”中，可能涉及以下几个关键知识点： 1. **线程的创建**：在Java中，可以通过两种方式创建线程。一种是继承`java.lang.Thread`类并重写`run()`方法，然后创建该类的实例并调用`start()`...
第8章 多线程设计1
08-03
第8章 多线程设计多线程机制线程通信22 October 2019多线程机制v线程就是应用程序中的一个可执行线索，多线程就是同一个应用程序中有多个可执行线索，它
第10章 多线程.docx
12-31
《第10章 多线程》主要涵盖了关于并发、并行、进程和线程的基础概念，以及如何在Java中创建和管理线程。以下是详细的知识点解析： 1. **并发与并行**： - **并发**：指的是在一段时间内，多个事件看似同时发生，但...
第14章多线程.pdf
09-30
Java语言提供了丰富的多线程支持，而本文件似乎是一本关于Java多线程技术的书籍或教程的第14章。 从提供的内容来看，该章节可能涵盖了一系列的Java多线程编程概念和技术： 1. 线程的创建和执行：在Java中，可以...
javase之通过生产者消费者模式解决死锁
Richard_666的博客
02-24 246
package com.ljl.thread; /** * 一个场景,共同的资源 * 生成者消费者模式--信号灯法 * @author Richard * wait() :等待，释放锁 * sleep() :等待，不释放锁 * notify()/notifyAll() :唤醒 与synchronized一起使用 * */ public class Movie { pri...
Java基础学习Day14--多线程
qq_45732338的博客
07-06 665
Java基础学习Day14--多线程
【线程】关于一些疑惑
最新发布
jams3368的博客
03-08 665
1
java多线程：线程同步synchronized（不同步的问题、队列与锁），死锁的产生和解决
LifeGoesOn
08-18 1293
0、不同步的问题 并发的线程不安全问题： 多个线程同时操作同一个对象，如果控制不好，就会产生问题，叫做线程不安全。 我们来看三个比较经典的案例来说明线程不安全的问题。 0.1 订票问题 例如前面说过的黄牛订票问题，可能出现负数或相同。 线程创建方式&&黄牛订票模拟 0.2 银行取钱 再来看一个取钱的例子： /* 模拟一个账户 */ class Account{ int money; String name; public Account(int money,
Java 对象锁和类锁 死锁（多线程synchronized关键字）
hugh 的博客
03-18 4279
本文主要是将synchronized关键字用法作为例子来去解释Java中的对象锁 和 类锁。一、synchronized关键字synchronized关键字有如下两种用法：1、 在需要同步的方法的方法签名中加入synchronized关键字。synchronized public void getValue() { System.out.println("getValue method th
java 同一个类中 多个synchronized 方法会造成死锁
weixin_33911824的博客
01-04 533
今天写java的时候，在一个类中写入了2个synchronized方法。而方法1调用方法2，执行的时候老是卡住，无法往下走。经过查阅资料，发现synchronized方法执行的时候，synchronized方法影响的范围并不是单单方法本身，而是这个类中所有带有synchronized的方法，synchronized线程都会等待其执行完成。这样子a调用了b，而b又要等待a...
【java 多线程】多线程并发同步问题及解决方法
weixin_30699831的博客
11-18 1677
一、线程并发同步概念 线程同步其核心就在于一个“同”。所谓“同”就是协同、协助、配合，“同步”就是协同步调昨，也就是按照预定的先后顺序进行运行，即“你先，我等， 你做完，我再做”。 线程同步，就是当线程发出一个功能调用时，在没有得到结果之前，该调用就不会返回，其他线程也不能调用该方法。 就一般而言，我们在说同步、异步的时候，特指那些需要其他组件来配合或者需要一定时间来完成的任务。在多线程编程...
java多线程执行任务（工具升级版）
haohao_ding的博客
03-10 8493
昨天写的java多线程执行任务（工具）但是不能符合顺序执行计划的场景，下面升级一下原工具 [java多线程执行任务（工具）]: https://haohaoding.blog.csdn.net/article/details/123377795
java 多线程deme_Java中的多线程Demo
weixin_31193137的博客
02-24 137
一、关于Java多线程中的一些概念1.1 线程基本概念从JDK1.5开始，Java提供了3中方式来创建、启动多线程：方式一(不推荐)、通过继承Thread类来创建线程类，重写run()方法作为线程执行体；方式二、实现Runnable接口来创建线程类，重写run()方法作为线程执行体；方式三、实现Callable接口来创建线程类，重写run()方法作为线程执行体；不同的是，其中方式一的效果最差，是因...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值