JavaSE之多线程

最新推荐文章于 2024-10-08 21:30:52 发布
最新推荐文章于 2024-10-08 21:30:52 发布
阅读量104 收藏
点赞数 1
分类专栏： JavaSE Java多线程 文章标签： 多线程 java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qtds114/article/details/115634713
版权

文章目录

Java多线程

也是稍微整理了一下多线程基础的东西吧，再回顾一遍。

1 基本概念

1.1 线程与进程

进程

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

线程

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

1.2 线程调度

分时调度

  • 所有线程轮流使用 CPU 的使用权，平均分配每个线程占用 CPU 的时间。

抢占式调度

  • 优先让优先级高的线程使用 CPU，如果线程的优先级相同，那么会随机选择一个(线程随机性)，Java使用的为抢占式调度。

  • CPU使用抢占式调度模式在多个线程间进行着高速的切换。对于CPU的一个核新而言，某个时刻，只能执行一个线程，而 CPU的在多个线程间切换速度相对我们的感觉要快，看上去就是 在同一时刻运行。 其实，多线程程序并不能提高程序的运行速度，但能够提高程序运行效率，让CPU的 使用率更高。

1.3 同步与异步

同步:排队执行 , 效率低但是安全.

异步:同时执行 , 效率高但是数据不安全.

1.4 并发与并行

并发：指两个或多个事件在同一个时间段内发生。比如说1秒钟内有多少个人点击了这个按钮，这就是并发。

并行：指两个或多个事件在同一时刻发生（同时发生），比如现在有多少个用户在线，我左手画圆的同时右手画矩形等等。

2 线程创建

Java使用Thread类代表线程，所有的线程对象都必须是Thread类或其子类的实例。Java可以用四种方式来创建线程，如下所示：

1）继承Thread类创建线程（重点）

2）实现Runnable接口创建线程（重点）

3）使用Callable和Future创建线程（了解）

4）使用线程池例如用Executor框架

2.1 方式一：继承Thread类

继承Thread类创建线程：

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

  2. 重写Thread类的run() --> 将此线程执行的操作声明在run()中

  3. 创建Thread类的子类的对象

  4. 通过此对象调用start()：①启动当前线程 ② 调用当前线程的run()

    //创建线程方式1：继承thred类，重写run方法，调用start开启线程

//注意，线程开启不一定立即执行，由cpu调度执行
public class TestThred1 extends Thread{
    @Override
    public void run() {
        for (int i = 0; i < 20; i++) {
            System.out.println("我在看代码"+i);
        }
    }

    public static void main(String[] args) {
        //main线程，主线程

        //创建一个线程对象
        TestThred1 testThred1 = new TestThred1();

        //调用start()方法开启线程
        testThred1.start();

        for (int i = 0; i < 2000; i++) {
            System.out.println("我在学习多线程"+i);
        }
    }
}

说明两个问题：
问题一：我们启动一个线程，必须调用start()，不能调用run()的方式启动线程。
问题二：如果再启动一个线程，必须重新创建一个Thread子类的对象，调用此对象的start().

2.2 方式二：实现Runnable接口创建线程

相较于继承Thread的好处：

1、 通过创建任务，然后线程分配的方式来实现多线程，更适合多个线程同时执行任务的情况。

2、 可以避免单继承所带来的局限性

//创建线程方式二：实现runnable接口，重写run方法，执行线程需要丢入runnable接口实现类，调用strat方法
public class TestThread3 implements Runnable{

    @Override
    public void run() {
        //run方法线程体
        for (int i = 0; i < 200; i++) {
            System.out.println("我在看代码："+i);
        }
    }

    public static void main(String[] args) {
        //创建runnable接口的实现类对象
        TestThread3 testThread3 = new TestThread3();

        //创建线程对象,通过线程对象来开启线程，代理
//        Thread thread =new Thread(testThread3);
//        thread.start();

        new Thread(testThread3).start();
        for (int i = 0; i < 200; i++) {
            System.out.println("我在学习多线程："+i);
        }
    }
}

2.3 方式三：实现Callable接口创建线程

1.实现Callable接口，需要返回值类型

2.重写call方法，需要抛出异常

3.创建目标对象

4.创建执行服务 ExecutorService service = Executors.newFixedThreadPool(3);

5.提交执行 Future result1 =service.submit(t1);

6.获取结果 System.out.println(result1.get());

7.关闭服务 service.shutdownNow();

public class TestCallable implements Callable<Boolean> {

    @Override
    public Boolean call() throws Exception {
        System.out.println("123");
        return true;
    }

    public static void main(String[] args) {

        TestCallable t1 =new TestCallable();
        TestCallable t2 =new TestCallable();
        TestCallable t3 =new TestCallable();

        //创建执行服务：（线程池）
        ExecutorService service = Executors.newFixedThreadPool(3);

        //提交执行
        Future<Boolean> result1 =service.submit(t1);
        Future<Boolean> result2 =service.submit(t2);
        Future<Boolean> result3 =service.submit(t3);

        try {
            //获取结果
            System.out.println(result1.get());
            System.out.println(result2.get());
            System.out.println(result3.get());
        } catch (InterruptedException | ExecutionException e) {
            e.printStackTrace();
        } finally {
            //关闭服务
            service.shutdownNow();
        }
    }
}

callable的好处：

1可以定义返回值

2可以抛出异常

2.4 Lambda表达式

理解Functional interface（函数式接口） 是学习Java 8 Lambda表达式的关键。

函数式接口定义：

  • 任何接口，如果只包含唯一一个抽象方法，那么他就是一个函数式接口。
  • 对于函数式接口，我们可以通过lambda表达式来创建该接口的对象。
/*
    推导lambda表达式
 */
//1.定义一个接口
interface iLike{
    void lambda();
}
//2.实现类
class Like implements iLike{
    public void lambda() {
        System.out.println("i like lambda");
    }
}
public class TestLambda {
    //3.静态内部类
    static class Like2 implements iLike{
        public void lambda() {
            System.out.println("lambda2");
        }
    }
    public static void main(String[] args) {
        iLike like =new Like();
        like.lambda();
        iLike like2 =new Like2();
        like2.lambda();
        //4.局部内部类
        class like3 implements iLike{
            public void lambda() {
                System.out.println("lambda3");
            }
        }
        iLike like3 = new like3();
        like3.lambda();
        //5.匿名内部类,没有类名，必须借助接口或者父类
        like =new iLike() {
            public void lambda() {
                System.out.println("lambda4");
            }
        };
        like.lambda();
        //6.用lambda简化
        like =() ->{
            System.out.println("lambda5");
        };
        like.lambda();
    }
}

使用：

interface iLove{
    void love(int a，int b);
}
public class TestLambda2 {
    public static void main(String[] args) {

        //1 lambda表达式简化
        iLove love =(int a) -> {
            System.out.println(a);
        };
        love.love(1);

        //简化1：参数类型
        iLove love2 =(a) -> {
            System.out.println(a+a);
        };
        love2.love(2);
        //简化2：简化括号（多个参数不能这样简化）
        iLove love3 =a -> {
            System.out.println(a);
        };
        love3.love(3);
        //简化3：简化大括号（只有一行语句的情况下）
        iLove love4 =a -> System.out.println(a);
        love4.love(4);

    }
}

3 多线程使用

3.1 Thread常用方法

Thread类中的常用的方法:

  1. start():启动当前线程；调用当前线程的run()

  2. run(): 通常需要重写Thread类中的此方法，将创建的线程要执行的操作声明在此方法中

  3. currentThread():静态方法，返回执行当前代码的线程

  4. getName():获取当前线程的名字

  5. setName():设置当前线程的名字

  6. yield():释放当前cpu的执行权

  7. join():在线程a中调用线程b的join(),此时线程a就进入阻塞状态，直到线程b完全执行完以后，线程a才结束阻塞状态。

  8. stop():已过时。当执行此方法时，强制结束当前线程。

  9. sleep(long millitime):让当前线程“睡眠”指定的millitime毫秒。在指定的millitime毫秒时间内，当前线程是阻塞状态。

  10. isAlive():判断当前线程是否存活

3.2 优先级

线程的优先级：

1.MAX_PRIORITY：10

MIN _PRIORITY：1

NORM_PRIORITY：5 -->默认优先级

2.如何获取和设置当前线程的优先级：

getPriority():获取线程的优先级

setPriority(int p):设置线程的优先级

说明：高优先级的线程要抢占低优先级线程cpu的执行权。但是只是从概率上讲，高优先级的线程高概率的情况下被执行。并不意味着只当高优先级的线程执行完以后，低优先级的线程才执行。

3.3 守护线程

线程的分类：一种是守护线程，一种是用户线程。

用户线程：当一个进程不包含任何存活的用户线程时，进行结束。

守护线程：守护用户线程，当最后一个用户线程结束时，所有守护线程跟着结束。

设置方式：t1.setDaemon(true);

3.4 线程安全

3.4.1 问题
// 多个线程同时操作同一个对象
// 买火车票的例子
// 发现问题：多个线程操作同一个导致数据问题
public class TestThread4 implements Runnable{

    //票数
    private int ticketNums = 10;

    public void run() {
        while (true){
            if (ticketNums<=0){
                break;
            }

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

            System.out.println(Thread.currentThread().getName()+"拿到了第"+ticketNums+"张票");
            ticketNums--;
        }

    }

    public static void main(String[] args) {
        TestThread4 testThread4 = new TestThread4();

        new Thread(testThread4,"小明").start();
        new Thread(testThread4,"老师").start();
        new Thread(testThread4,"黄牛").start();
    }
}

解决办法：

1加锁，变成同步方法或同步代码块(效率慢)

3.4.2 同步代码块

同步代码块的方式：

public class TestThread5 implements Runnable{
    //票数
    private int ticketNums = 10;
    // run方法前也可以加锁，
    // 但循环在方法内部，加锁就只能等到线程的while结束才会释放
    // 同步方法的方式见后
    public void run() {
        while (true){
            // 同步代码块，this锁对象（main中的testThread5对象）
            synchronized (this){
                if (ticketNums<=0){
                    break;
                }
                try {
                    Thread.sleep(200);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }

                System.out.println(Thread.currentThread().getName()+"拿到了第"+ticketNums+"张票");
                ticketNums--;
            }
        }

    }

    public static void main(String[] args) {
        TestThread5 testThread5 = new TestThread5();

        new Thread(testThread5,"小明").start();
        new Thread(testThread5,"老师").start();
        new Thread(testThread5,"黄牛").start();
    }
}
3.4.3 同步方法

同步方法的方式:

public class TestThread6 implements Runnable {

    private int ticketNums = 10;

    public void run() {
        while (true) {
            boolean f = sale();
            if(!f) break;
        }
    }
    // 通过同步方法的方式加锁
    public synchronized boolean sale() {
        if (ticketNums <= 0) return false;

        try {
            Thread.sleep(200);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println(Thread.currentThread().getName() + "拿到了第" + ticketNums + "张票");	
		ticketNums--;
        
        return true;
    }

    public static void main(String[] args) {
        TestThread6 testThread6 = new TestThread6();

        new Thread(testThread6, "小明").start();
        new Thread(testThread6, "老师").start();
        new Thread(testThread6, "黄牛").start();
    }
}

**注意：**如果线程操作方法或属性被static修饰了，那么锁操作的就是类而不是对象，也就是说无论创建多少个对象，对static属性或方法的操作都是基于类的！

举例：没有static的话，如果多个线程操作不同对象，他们会并行的执行任务，他们是互不相关的；

而有static的话，无论有多少个对象，操作的都是同一个类中的数据！

3.4.4 显式锁Lock类
public class TestThread7 implements Runnable {

    private int ticketNums = 10;
    // 显式锁
    private Lock lock = new ReentrantLock();

    public void run() {
        while (true) {
            lock.lock();
            if (ticketNums <= 0) break;

            try {
                Thread.sleep(200);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println(Thread.currentThread().getName() + "拿到了第" + ticketNums-- + "张票");

            lock.unlock();
        }
    }

    public static void main(String[] args) {
        TestThread7 t = new TestThread7();

        new Thread(t, "小明").start();
        new Thread(t, "老师").start();
        new Thread(t, "黄牛").start();
    }
}

3.5 公平锁

公平锁：排队，先来后到

非公平锁：可以插队

3.6 死锁

两个进程都在等待对方上锁的资源释放，就会造成死锁（也可能是多个线程循环等待）：

// 电脑速度刚好合适的话可能较难产生死锁，直接调试即可
public class demo1 {
    public static void main(String[] args) {
        Player p = new Player();
        Man m = new Man();

        new MyThread(p,m).start();

        m.say(p);

    }
    static class MyThread extends Thread{
        public Player p;
        public Man m;

        public MyThread(Player p, Man m) {
            this.p = p;
            this.m = m;
        }

        @Override
        public void run() {
            p.say(m);
        }
    }
    static class Player{
        public synchronized void say(Man m){
            System.out.println("好耶！！！");
            m.say2();
        }
        public synchronized void say2(){
            System.out.println("禁止好耶！！！");
        }
    }
    static class Man{

        public synchronized void say(Player p){
            System.out.println("禁止好耶！！！");
            p.say2();
        }

        public synchronized void say2(){
            System.out.println("禁止禁止好耶！！！");
        }
    }
}

4 多线程状态

4.1 概述

image-20210205154853109

//Thread内的源码
public enum State {
    //线程新生
    NEW,
    
	//运行
    RUNNABLE,

    //阻塞
    BLOCKED,

    //等待
    WAITING,

    //超时等待
    TIMED_WAITING,

    //死亡
    TERMINATED;
}

4.2 线程通信

线程通信：

1.线程通信涉及到的三个方法：

  • wait():一旦执行此方法，当前线程就进入阻塞状态，并释放同步监视器。
  • notify():一旦执行此方法，就会唤醒被wait的一个线程。如果有多个线程被wait，就唤醒优先级高的那个。
  • notifyAll():一旦执行此方法，就会唤醒所有被wait的线程。

2.说明：

  • 1.wait()，notify()，notifyAll()三个方法必须使用在同步代码块或同步方法中。
  • 2.wait()，notify()，notifyAll()三个方法的调用者必须是同步代码块或同步方法中的同步监视器。
  • 否则，会出现IllegalMonitorStateException异常
  • 3.wait()，notify()，notifyAll()三个方法是定义在java.lang.Object类中。

3.面试题：
面试题：sleep() 和 wait()的异同？

1.相同点：一旦执行方法，都可以使得当前的线程进入阻塞状态。

2.不同点：

1）两个方法声明的位置不同：Thread类中声明sleep() , Object类中声明wait()

2）调用的要求不同：sleep()可以在任何需要的场景下调用。 wait()必须使用在同步代码块或同步方法中

3）关于是否释放同步监视器：如果两个方法都使用在同步代码块或同步方法中，sleep()不会释放锁，wait()会释放锁。

4）sleep需要捕获异常，wait不需要

4.3 生产者消费者问题
public class Demo4  {

    /**
     * 多线程通信问题, 生产者与消费者问题
     * @param args
     */
    public static void main(String[] args) {
        Food f = new Food();
        new Cook(f).start();
        new Waiter(f).start();
    }

    //厨师
    static class Cook extends Thread{
        private Food f;
        public Cook(Food f) {
            this.f = f;
        }

        @Override
        public void run() {
            for(int i=0;i<100;i++){
                if(i%2==0){
                    f.setNameAndSaste("老干妈小米粥","香辣味");
                }else{
                    f.setNameAndSaste("煎饼果子","甜辣味");
                }
            }
        }
    }
    //服务生
    static class Waiter extends Thread{
        private Food f;
        public Waiter(Food f) {
            this.f = f;
        }
        @Override
        public void run() {
            for(int i=0;i<100;i++){
                try {
                    Thread.sleep(100);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                f.get();
            }
        }
    }
    //食物
    static class Food{
        private String name;
        private String taste;

        //true 表示可以生产
        private boolean flag = true;

        public synchronized void setNameAndSaste(String name,String taste){
            if(flag) {
                this.name = name;
                try {
                    Thread.sleep(100);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                this.taste = taste;
                flag = false;
                this.notifyAll();
                try {
                    this.wait();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        }
        public synchronized void get(){
            if(!flag) {
                System.out.println("服务员端走的菜的名称是:" + name + ",味道:" + taste);
                flag = true;
                this.notifyAll();
                try {
                    this.wait();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        }
    }
}

5 线程池Executors

5.1 概述

如果并发的线程数量很多，并且每个线程都是执行一个时间很短的任务就结束了，这样频繁创建线程

就会大大降低 系统的效率，因为频繁创建线程和销毁线程需要时间. 线程池就是一个容纳多个线程的容

器，池中的线程可以反复使用，省去了频繁创建线程对象的操作，节省了大量的时间和资源。

线程池的好处

  • 降低资源消耗。
  • 提高响应速度。
  • 提高线程的可管理性。

Java中的4种线程池

  • 缓存线程池
  • 定长线程池
  • 单线程线程池
  • 周期任务 定长线程池

5.2 缓存线程池

public class Demo {
    /** 缓存线程池
     * (长度无限制)
     * 执行流程:
     * 1. 判断线程池是否存在空闲线程
     * 2. 存在则使用
     * 3. 不存在,则创建线程 并放入线程池, 然后使用
     */
    public static void main(String[] args) {
        // 向线程池中加入新的任务 / 指挥线程池执行新的任务
        ExecutorService service = Executors.newCachedThreadPool();

        service.execute(new Runnable() {
            @Override
            public void run() {
                System.out.println(Thread.currentThread().getName());
                // 让线程执行久一点保证线程2能创建出来
                try {
                    Thread.sleep(600);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        });
        
        // lambda表达式形式
        service.execute(() -> {
            System.out.println(Thread.currentThread().getName());
            // 让该线程死循环，不空闲
            while (true) {
            }
        });

//        // main线程睡一会保证线程1执行完
        try {
            Thread.sleep(1000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        // 使用了线程1
        service.execute(() -> System.out.println(Thread.currentThread().getName()));
        // 多创建几个也是用的线程1（电脑差的可能会看到线程3创建出来了）
        service.execute(() -> System.out.println(Thread.currentThread().getName()));

    }
}

5.3 定长线程池

public class Demo2 {
    /**
     * 定长线程池：长度是指定的数值
     * 任务加入后的执行流程：
     *       1. 判断线程池是否存在空闲线程
     *       2. 存在则使用
     *       3. 不存在空闲线程,且线程池未满的情况下,则创建线程 并放入线程池, 然后使用
     *       4. 不存在空闲线程,且线程池已满的情况下,则等待线程池存在空闲线程
     */
    public static void main(String[] args) {
        ExecutorService service = Executors.newFixedThreadPool(2);

        service.execute(()->{
            System.out.println(Thread.currentThread().getName());
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        });
        service.execute(()->{
            System.out.println(Thread.currentThread().getName());
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        });
        service.execute(()->{
            System.out.println(Thread.currentThread().getName());
        });
    }
}

5.4 单线程线程池

public class Demo3 {
    /** 
     *  单线程线程池 : 效果与定长线程池 创建时传入数值1 效果一致.
     *  执行流程:
     *  1. 判断线程池 的那个线程 是否空闲
     *  2. 空闲则使用
     *  3. 不空闲,则等待 池中的单个线程空闲后 使用
     */
    public static void main(String[] args) {
        ExecutorService service = Executors.newSingleThreadExecutor();

        service.execute(()-> System.out.println(Thread.currentThread().getName()));
        service.execute(()-> System.out.println(Thread.currentThread().getName()));
        service.execute(()-> System.out.println(Thread.currentThread().getName()));
    }
}
5.5 周期任务定长线程池
public class Demo4 {
    /**
     * 周期任务 定长线程池.
     * 执行流程:
     * 1. 判断线程池是否存在空闲线程
     * 2. 存在则使用
     * 3. 不存在空闲线程,且线程池未满的情况下,则创建线程 并放入线程池, 然后使用
     * 4. 不存在空闲线程,且线程池已满的情况下,则等待线程池存在空闲线程
     * <p>
     * 周期性任务执行时:
     * 定时执行, 当某个时机触发时, 自动执行某任务 .
     */
    public static void main(String[] args) {
        ScheduledExecutorService service = Executors.newScheduledThreadPool(2);
        /**
         * 定时执行一次
         *      参数1. runnable类型的任务
         *      参数2. 时长数字
         *      参数3. 时长数字的单位
         */
        service.schedule(() -> {
            System.out.println(Thread.currentThread().getName()+" abc");
        },3, TimeUnit.SECONDS);

        /**
         * 周期执行任务（每隔一段时间执行一次任务）
         * 参数1：任务
         * 参数2：延迟时长数字（第一次执行在什么时间以后）
         * 参数3：周期时长数字（每隔多久执行一次）
         * 参数4：时长数字单位
         */
        service.scheduleAtFixedRate(() -> {
            System.out.println(Thread.currentThread().getName()+" 222");
        },3,1, TimeUnit.SECONDS);

    }
}
qtds114
关注
专栏目录
JavaSE之多线程实战视频课程
06-09
JavaSE之多线程实战视频课程是一系列深入探讨Java中多线程技术的教程，适合对Java编程有一定基础的学习者。课程涵盖了多线程的基本概念，以及如何在Java环境中实现和管理多线程，旨在提升开发者对并发编程的理解和...
javase之多线程技术
10-16
Java中的多线程技术是Java进阶学习的重要组成部分，它涉及到并发编程的理论与实践，旨在提高程序的执行效率和响应速度。以下是对多线程技术的详细解释： 1. **CPU调度算法原理** - **先来先服务（FCFS）**：按照...
javaSE之多线程
qq_42964601的博客
09-28 136
Java多线程 *首先线程是由CPU调度的 1实现多线程的两种方法 *继承Thread类 *实现Runable接口 2线程常用的控制方法 *wait（）方法使线程等待进入阻塞状态，使用notify()/notifyAll方法将其唤醒，是由对象调度的 *sleep()方法使线程进入阻塞状态，由线程调度的 *join（）方法使线程进入阻塞状态，由线程调度的（调用此方法主线程将会被阻塞，直到调用此方法的...
javase之多线程
Richard_666的博客
02-23 261
进程：相当于我们电脑上的网易云音乐、eclipse分别代表一个进程 线程：相当于我点开网易云音乐可以边听歌，边看mv 多核（多个cpu）处理不同路径的任务才算得上真正的多线程 一个cpu处理多路径，算模拟多线程，因为时间碎片上，我们开启像同时在运行多个路径上的任务...
JAVASE之多线程初识
YoungLee16的博客
12-10 429
多线程: 进程:进程指正在运行的程序,确切的来说,当一个程序进入内存运行,即变成一个进程,进程是处于运行过程中的程序,并且具有一定独立功能. 线程:线程是进程中的一个执行单元,负责当前进程中程序的执行,一个进程中至少有一个线程.一个进程中是可以有多个线程的,这个应用程序也可以称之为多线程程序.   简而言之:一个程序运行后至少有一个进程,一个进程中可以包含多个线程. 多线程:即就是一个程
javaSE之多线程vip插队
小小雨伞的博客
10-07 605
//测试join方法 //想象为插队 public class TestJoin implements Runnable { @Override public void run() { for (int i = 0; i < 1000; i++) { System.out.println("线程vip来了"+i); } } public static void main(String[] args) throw
javaSE之多线程之礼让线程
小小雨伞的博客
10-07 182
礼让不一定成功,看CPU心情 package state; //测试礼让线程 public class Yield { public static void main(String[] args) { MyYield myYield =new MyYield(); new Thread(myYield,"A").start(); new Thread(myYield,"B").start(); } } class MyYi
JavaSE之多线程2
sclieshare的博客
07-06 1063
多线程技术线程的休眠线程堵塞线程中断jvm里线程的状态守护线程与用户线程线程安全问题解决线程不安全的三种加锁机制隐式锁同步代码块同步方法显式锁公平锁与非公平锁线程死锁 线程的休眠 public class Demo { public static void main(String[] args) throws InterruptedException { // 线程休眠 sleep for (int i = 0; i < 10; i++) {
JavaSE——多线程详细
weixin_51351637的博客
12-12 701
一个应用程序，一个进程就是一个软件：一个进程中的执行场景/执行单元对于java程序来说，当在DOS命令窗口中输入java HelloWorld回车之后，会先启动JVM，而JVM就是一个进程，JVM再启动一个主线程调用main方法，同时再启动一个垃圾回收线程负责看护，回收垃圾，也就是说java程序中至少有两个线程并发，一个是垃圾回收线程，一个是执行main方法的主线程。
javaSE之多线程之使用标志位控制线程停止
小小雨伞的博客
10-07 262
package state; public class TestStop implements Runnable { //设置一个标志位 private boolean flag = true; @Override public void run() { int i=0; while (flag){ System.out.println("run.....Thread"+i++); }
javaSE之多线程使用sleep模拟倒计时
小小雨伞的博客
10-07 340
//模拟倒计时 : 放大问题的反生性 public class TestSleep { public static void main(String[] args) { //打印系统当前时间 Date startDate =new Date(System.currentTimeMillis()); while (true){ try { Thread.sleep(1000);
JavaSE多线程
09-15
JavaSE的多线程特性是其强大的功能之一，它允许开发者编写能够同时处理多个任务的程序，从而提高程序的效率和响应性。在Java中，线程是程序执行的最小单位，而进程则是资源分配的基本单位。每个Java应用程序至少有一...
11、JavaSE：多线程.pdf
04-24
Java多线程编程是JavaSE（Standard Edition）核心技术之一，被广泛应用于复杂应用系统的设计中，以实现高效的并发处理。 首先，我们要理解什么是线程。线程，也可以理解为进程内部的执行路径，是程序中最小的执行...
JavaSE异常与多线程
06-04
入门级笔记，适合查漏补缺。
JDK1.0主要特性
FoolRabbit的专栏
10-06 689
JDK1.0主要特性。
2024Java最新面试题总结（针对于一些小厂、中厂）
weixin_62375676的博客
10-07 1466
2024最新Java面试题，针对一些小厂，中厂
已解决-Sentinel控制台明明正常启动，扫描不到客户端应用
最新发布
qq_46248151的博客
10-08 622
经排查才发现，我在启动了Sentinel控制台之后，对SpringBoot应用做了配置的更新，于是重启了SpringBoot服务，这时SpringBoot是没有任何访问的。今天启动Sentinel控制台的时候，明明启动成功，无报错，浏览器能正常访问，但就是无论如何都刷新不出来应用。
Spring Boot新闻推荐系统设计与实现
2402_85758936的博客
10-04 1606
目前，界面设计已经成为对软件质量进行评价的一条关键指标，一个好的用户界面可以使用户使用系统的信心和兴趣增加，从而使工作效率提高，JSP技术是将JAVA语言作为脚本语言的，JSP网页给整个服务器端的JAVA库单元提供了一个接口用来服务HTTP的应用程序。一旦输入系统的数据不正确，那么处理后的输出就会扩大这些错误，因此输入的数据的准确性对整个系统的性能起着决定性意义。输出是由电脑对输入的基本信息进行解决，生成高质量的有效信息，并使之具有一定的格式，提供给管理者使用，这是输出设计的主要责任和目标。
JavaSE多线程编程详解：创建与管理
"JavaSE多线程编程专题.pptx" 在JavaSE中，多线程编程是一项核心技能，它允许程序并发执行多个任务，提高系统资源利用率和响应速度。多线程涉及到进程和线程两个概念。进程是操作系统分配资源的基本单位，每个进程...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值