【Java基础】线程

最新推荐文章于 2024-10-17 10:27:13 发布
最新推荐文章于 2024-10-17 10:27:13 发布
阅读量1.6k 收藏 22
点赞数 48
文章标签： java 开发语言
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_55839915/article/details/136735793
版权

线程

基本概念

进程

1.进程是指运行中的程序，使用QQ就相当于启动了一个进程，操作系统就会为该进程分配内存空间

2.进程是程序的一次执行过程，或是正在运行的一个程序，是动态过程：有它自身的产生、存在和消亡的过程

线程

1.线程是由进程创建的，是进程的一个实体

2.一个进程可以拥有多个线程

其它相关概念

1.单线程：同一个时刻，只允许执行一个线程

2.多线程：同一个时刻，可以执行多个线程，比如：一个qq进程，可以同时打开多个聊天窗口

3.并发：同一个时刻，多个任务交替执行，造成一种“貌似同时”的错觉，简单的说，单核cpu实现的多任务就是并发

4.并行：同一个时刻，多个任务同时执行，多核cpu可以实现并行

5.并发和并行可以同时存在

public class CpuNum {
    public static void main(String[] args) {

        Runtime runtime = Runtime.getRuntime();
        // 获取当前电脑的cpu数量
        int cpuNum = runtime.availableProcessors();
        System.out.println("当前有CPU的个数：" + cpuNum);
    }
}

        int cpuNum = runtime.availableProcessors();
        System.out.println("当前有CPU的个数：" + cpuNum);
    }
}

线程的基本使用

创建线程的两种方式

在java中线程的使用有两种方法

1.继承Thread类，重写run方法

2.实现Runnable接口，重写run方法

继承Thread类

Thread01:

public class Thread01 {
    public static void main(String[] args) throws InterruptedException {
        // 创建Cat对象，可以当做线程使用
        Cat cat = new Cat();
        cat.start(); // 启动线程 -> 最终会执行cat的run方法

        /*
            源码：
            1.
            public synchronized void start() {
                start0();
            }

            2.
            // start0() 是本地方法，由JVM调用，底层是c/c++实现
            // 真正实现多线程的效果，是 start0()，而不是 run方法
            private native void start0();
        */

        // run方法就是一个普通的方法，并不会开启子线程
        // 直到把run方法执行完毕才会向下执行
        // cat.run();

        // 当main线程启动一个子线程 Thread-0，主线程不会阻塞，会继续执行
        // 这时 主线程和子线程是交替执行...
        System.out.println("主线程继续执行 线程名：" + Thread.currentThread().getName());
        for (int i = 0; i < 6; i++) {
            System.out.println("主线程 i=" + i);
            // 让主线程休眠
            Thread.sleep(1000);
        }
    }
}

// 1. 当一个类继承了 Thread类，该类就可以当做线程使用
// 2. 重写run方法，写上自己的业务代码
// 3. run Thread类 实现了 Runnable接口的 run方法
/*
    @Override
    public void run() {
        if (target != null) {
            target.run();
        }
    }
*/
class Cat extends Thread {
    int times = 0;
    @Override
    public void run() { // 重写run方法
        while (true) {
            // 该线程每隔1秒，在控制台输出“hello”
            System.out.println("hello" + times++ + " 线程名：" + Thread.currentThread().getName());
            // 让该线程休眠1秒 ctrl+alt+t
            try {
                Thread.sleep(1000); // 1000ms = 1s
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            if (times == 8) {
                break; // 当 times到 8，就退出while。这时线程也就退出
            }
        }
    }
}

Java43

实现Runnable接口

Thread02:

public class Thread02 {
    public static void main(String[] args) {
//        Dog dog = new Dog();
//        // dog.start(); // 没有该方法
//        // 创建了 Thread对象，把 dog对象（实现Runnable），放入Thread
//        Thread thread = new Thread(dog);
//        thread.start();

        Tiger tiger = new Tiger();
        ThreadProxy threadProxy = new ThreadProxy(tiger);
        threadProxy.start();
    }
}

class Animals {

}

class Tiger extends Animals implements Runnable {

    @Override
    public void run() {
        System.out.println("老虎嗷嗷叫... ");
    }
}

// 线程代理类，模拟一个极简的 Thread类
class ThreadProxy implements Runnable {
    // 把 ThreadProxy类当做 线程代理
    private Runnable target = null; // 属性，类型是 Runnable

    @Override
    public void run() {
        if (target != null) {
            target.run(); // 动态绑定（运行类型 Tiger）
        }
    }

    public ThreadProxy(Runnable target) {
        this.target = target;
    }

    public void start() {
        start0(); // 这个方法真正实现多线程
    }

    public void start0() {
        run();
    }
}

class Dog implements Runnable {

    // 通过实现 Runnable接口，开发线程
    int count = 0;
    @Override
    public void run() {
        while (true) {
            System.out.println("小狗汪汪叫..hi " + (++count) + " " + Thread.currentThread().getName());
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            if (count == 10) {
                break;
            }
        }
    }
}

多线程执行

Thread03:

public class Thread03 {
    public static void main(String[] args) {
        T1 t1 = new T1();
        Thread thread1 = new Thread(t1);
        thread1.start();

        T2 t2 = new T2();
        Thread thread2 = new Thread(t2);
        thread2.start();
    }
}

class T1 implements Runnable {

    @Override
    public void run() {
        int count = 0;
        while (true) {
            System.out.println("hello,world " + (++count));
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            if (count == 10) {
                break;
            }
        }
    }
}

class T2 implements Runnable {

    @Override
    public void run() {
        int count = 0;
        while (true) {
            System.out.println("hi " + (++count));
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            if (count == 5) {
                break;
            }
        }
    }
}

继承Thread vs 实现Runnable接口的区别

1.从java的设计来看，通过继承Thread或者实现Runnable接口来创建线程本质上没有区别，
从jdk帮助文档可以看到Thread类本身就实现了Runnable接口

2.实现Runnable接口方式更加适合多个线程共享一个资源的情况，并且避免了单继承的限制，
建议使用Runnable

线程终止

基本说明

1.当线程完成任务后，会自动退出

2.还可以通过使用变量来控制run方法退出的方式停止线程，即通知方式

ThreadExit_：

public class ThreadExit_ {
    public static void main(String[] args) throws InterruptedException {
        T t1 = new T();
        t1.start();

        // 如果希望 main线程去控制 t1线程的终止，必须可以修改 loop变量
        // 让 t1 退出 run方法，从而终止 t1线程 -> 通知方式

        // 让 主线程休眠 10秒，再通知 t1线程退出
        System.out.println("main线程休眠10s...");
        Thread.sleep(10 * 1000);
        t1.setLoop(false);
    }
}


class T extends Thread {
    private int count = 0;
    // 设置一个控制变量
    private boolean loop = true;

    @Override
    public void run() {
        while (loop) {
            try {
                Thread.sleep(50);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println("T 运行中... " + (++count));
        }
    }

    public void setLoop(boolean loop) {
        this.loop = loop;
    }
}

线程常用方法

第一组

1.setName // 设置线程名称，使之于参数name相同

2.getName // 返回该线程的名称

3.start // 使该线程开始执行；Java虚拟机底层调用该线程的start0方法

4.run // 调用线程对象run方法

5.setPriority // 更改线程的优先级

6.getPriority // 获取线程的优先级

7.sleep // 在指定的毫秒数内让当前正在执行的线程休眠（暂停执行）

8.interrupt // 中断线程

注意事项和细节

1.start底层会创建新的线程，调用run，run就是一个简单的方法调用，不会启动新线程

2.线程优先级的范围

3.interrupt，中断线程，但并没有真正的结束线程，所以一般用于中断正在休眠的线程

4.sleep，线程的静态方法，使当前线程休眠

ThreadMethod01：

public class ThreadMethod01 {
    public static void main(String[] args) throws InterruptedException {
        T t = new T();
        t.setName("hsp");
        t.setPriority(Thread.MIN_PRIORITY);
        t.start(); // 启动子线程

        // 主线程打印 5个 hi，就中断子线程的休眠
        for (int i = 0; i < 5; i++) {
            Thread.sleep(1000);
            System.out.println("hi ... " + i);
        }

        System.out.println(t.getName() + " 线程的优先级=" + t.getPriority()); // 1
        t.interrupt(); // 当执行到这里，就会 t线程的休眠
    }
}

class T extends Thread {
    @Override
    public void run() {
        while (true) {
            for (int i = 0; i < 100; i++) {
                System.out.println(Thread.currentThread().getName() + " 吃东西..." + i);
            }
            try {
                System.out.println(Thread.currentThread().getName() + " 休眠中...");
                Thread.sleep(20000);
            } catch (InterruptedException e) {
                // 当线程执行到一个interrupt方法时，就会catch一个异常，可以加入业务代码
                // InterruptedException 是捕获到一个中断异常
                System.out.println(Thread.currentThread().getName() + " 被 interrupt了...");
            }
        }
    }
}

第二组

1.yield // 线程的礼让。让出CPU，让其他线程执行，但礼让的时间不确定，所以也不一定礼让成功

2.join // 线程的插队。插队的线程一旦插队成功，则肯定先执行完插入的线程的所有的任务

ThreadMethod02：

public class ThreadMethod02 {
    public static void main(String[] args) throws InterruptedException {
        T2 t2 = new T2();
        t2.start();

        for (int i = 0; i <= 20; i++) {
            Thread.sleep(1000);
            System.out.println("主线程 吃了 " + i + "个包子");
            if (i == 5) {
                System.out.println("主线程 让 子线程 先吃...");
                // join 线程插队
                //t2.join(); // 这里相当于 t2线程先执行完毕

                Thread.yield(); // 礼让，不一定成功

                System.out.println("主线程吃完了，子线程继续吃...");
            }
        }
    }
}

class T2 extends Thread {
    @Override
    public void run() {
        for (int i = 0; i <= 20; i++) {
            try {
                Thread.sleep(1000); // 休眠1秒
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println("子线程 吃了 " + i + "个包子");
        }
    }
}

ThreadMethodExercise：

public class ThreadMethodExercise {
    public static void main(String[] args) throws InterruptedException {
        T3 t3 = new T3();
        Thread thread = new Thread(t3);

        for (int i = 1; i <= 10; i++) {
            System.out.println("hi " + (i));
            Thread.sleep(1000);
            if (i == 5) {
                thread.start();
                thread.join(); // 让子线程插队
            }
            if (i == 10) {
                System.out.println("主线程结束...");
                break;
            }
        }
    }
}

class T3 implements Runnable {

    @Override
    public void run() {
        for (int i = 1; i <= 10; i++) {
            System.out.println("hello " + (i));
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            if (i == 10) {
                System.out.println("子线程结束...");
                break;
            }
        }
    }
}

用户线程和守护线程

1.用户线程（工作线程）：当线程的任务执行完或通知方式结束

2.守护线程：一般是为工作线程服务的，当所有的用户线程结束，守护线程自动结束

3.常见的守护线程：垃圾回收机制

ThreadMethod03：

public class ThreadMethod03 {
    public static void main(String[] args) throws InterruptedException {
        MyDeamonThread myDeamonThread = new MyDeamonThread();
        // 希望当main线程结束后，子线程自动结束
        // 只需将子线程设为守护线程
        myDeamonThread.setDaemon(true);
        myDeamonThread.start();
        for (int i = 0; i <= 10; i++) {
            System.out.println("工作...");
            Thread.sleep(1000);
        }
    }
}

class MyDeamonThread extends Thread {
    @Override
    public void run() {
        for ( ; ; ) { // 无限循环
            try {
                Thread.sleep(1000); // 休眠1000毫秒
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println("哈哈哈...");
        }
    }
}

线程的生命周期

线程状态转换图

Java44

ThreadState_:

public class ThreadState_ {
    public static void main(String[] args) throws InterruptedException {
        T t = new T();
        System.out.println(t.getName() + " 状态 " + t.getState());
        t.start();

        while (Thread.State.TERMINATED != t.getState()) {
            System.out.println(t.getName() + " 状态 " + t.getState());
            Thread.sleep(500);
        }

        System.out.println(t.getName() + " 状态 " + t.getState());
    }
}

class T extends Thread {
    @Override
    public void run() {
        while (true) {
            for (int i = 0; i < 10; i++) {
                System.out.println("hi " + i);
                try {
                    Thread.sleep(1000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
            break;
        }
    }
}

Synchronized

线程同步机制

1.在多线程编程，一些敏感数据不允许被多个线程同时访问，此时就使用同步访问技术，
保证数据在任何同一时刻，最多只有一个线程访问，以保证数据的完整性

2.也可以这样理解：线程同步，即当有一个线程在对内存进行操作时，其他线程都不可以对这个
内存地址进行操作，直到该线程完成操作，其他线程才能对该内存地址

互斥锁基本介绍

1.Java语言中，引入了对象互斥锁的概念，来保证共享数据操作的完整性

2.每个对象都对应于一个可称为“互斥锁”的标记，这个标记用来保证在任一时刻，
只能有一个线程访问该对象

3.通过关键字synchronized来与对象的互斥锁进行联系，当某个对象用synchronized修饰时，
表明该对象在任一时刻只能由一个线程访问

4.同步的局限性：导致程序的执行效率要降低

5.同步方法（非静态的）的锁可以是this，也可以是其他对象（要求是同一个对象）

6.同步方法（静态的）的锁为当前类本身

同步具体方法

1.同步代码块

synchronized(对象) { // 得到对象的锁，才能操作同步代码
    // 需要被同步的代码;
}

2.synchronized还可以放在方法声明中，表示整个方法为同步方法

public synchronized void m(String name) {
    // 需要被同步的代码;
}

实现接口方式，使用互斥锁实现线程同步

SellTicketSyn：

public class SellTicketSyn {
    public static void main(String[] args) {

        // 使用synchronized方法
        SellTicket03 sellTicket03 = new SellTicket03();
        Thread thread1 = new Thread(sellTicket03);
        Thread thread2 = new Thread(sellTicket03);
        Thread thread3 = new Thread(sellTicket03);

        thread1.start();
        thread2.start();
        thread3.start();
    }
}

// 实现接口方式，使用synchronized实现线程同步
class SellTicket03 implements Runnable {

    private static int ticketNum = 100; // 让多个线程共享，票数
    private static boolean loop = true; // 控制run方法变量

    Object obj = new Object();

    // 非静态：
    // 1. public synchronized void m1() {} 就是一个同步方法
    // 2. 这时候的锁 在 this对象
    // 3. 也可以在代码块上写synchronized，同步代码块 m2

    public synchronized void m1() {
        // 同步方法，在同一时刻，只能有一个线程来执行sell方法
        if (ticketNum <= 0) {
            System.out.println("售票结束...");
            loop = false;
            return;
        }

        // 休眠50毫秒，模拟
        try {
            Thread.sleep(50);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println("窗口 " + Thread.currentThread().getName() + "售出一张票 "
                + "剩余票数=" + (--ticketNum));
    }

    public void m2() {
        synchronized (/*this*/obj) { // 可以是object对象，但是必须是同一个对象
            if (ticketNum <= 0) {
                System.out.println("售票结束...");
                loop = false;
                return;
            }

            // 休眠50毫秒，模拟
            try {
                Thread.sleep(50);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println("窗口 " + Thread.currentThread().getName() + "售出一张票 "
                    + "剩余票数=" + (--ticketNum));
        }
    }

    // 同步方法（静态的）的锁为当前类本身
    // 1. public synchronized static void m3() {} 的锁是加在 SellTicket03.class
    // 2. 如果在静态方法中，实现一个同步代码块

    public synchronized static void m3() {
        if (ticketNum <= 0) {
            System.out.println("售票结束...");
            loop = false;
            return;
        }

        // 休眠50毫秒，模拟
        try {
            Thread.sleep(50);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println("窗口 " + Thread.currentThread().getName() + "售出一张票 "
                + "剩余票数=" + (--ticketNum));
    }


    public static void m4() {
        synchronized (SellTicket03.class) {
            if (ticketNum <= 0) {
                System.out.println("售票结束...");
                loop = false;
                return;
            }

            // 休眠50毫秒，模拟
            try {
                Thread.sleep(50);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println("窗口 " + Thread.currentThread().getName() + "售出一张票 "
                    + "剩余票数=" + (--ticketNum));
        }
    }

    @Override
    public void run() {
        while (loop) {
            try {
                Thread.sleep(50);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }

//            m1(); // 同步方法
//            m2();
//            m3();
            m4();
        }
    }
}

注意事项和细节

1.同步方法如果没有使用static修饰：默认锁对象为this

2.如果方法使用static修饰，默认锁对象：当前类.class

3.实现的落地步骤：
a.需要先分析上锁的代码
b.选择同步代码块或同步方法
c.要求多个线程的锁对象为同一个即可(必须为同一个对象)

线程的死锁

基本介绍

多个线程都占用了对方的锁资源，但互不相让，导致了死锁，在编程中一定要避免死锁的发生

DeadLock_：

public class DeadLock_ {
    public static void main(String[] args) {
        // 模拟死锁现象
        DeadLockDemo A = new DeadLockDemo(true);
        A.setName("A线程");
        DeadLockDemo B = new DeadLockDemo(false);
        B.setName("B线程");
        A.start();
        B.start();
    }
}

// 线程
class DeadLockDemo extends Thread {
    static Object o1 = new Object(); // 保证多线程共享一个对象，使用static
    static Object o2 = new Object();
    boolean flag;

    public DeadLockDemo(boolean flag) {
        this.flag = flag;
    }

    @Override
    public void run() {
        // 下面的业务逻辑分析：
        // 1. 如果 flag为true，线程A 就会先得到 o1对象锁，然后尝试去获取 o2对象锁
        // 2. 如果 线程A 得不到 o2对象锁，就会 Blocked
        // 3. 如果 flag为false，线程B 就会先得到 o2对象锁，然后尝试去获取 o1对象锁
        // 4. 如果 线程B 得不到 o1对象锁，就会 Blocked
        if (flag) {
            synchronized (o1) { // 对象互斥锁，下面就是同步代码
                System.out.println(Thread.currentThread().getName() + " 进入1");
                synchronized (o2) { // 这里获得li对象的监视权
                    System.out.println(Thread.currentThread().getName() + " 进入2");
                }
            }
        } else {
            synchronized (o2) { // 对象互斥锁
                System.out.println(Thread.currentThread().getName() + " 进入3");
                synchronized (o1) { // 这里获得li对象的监视权
                    System.out.println(Thread.currentThread().getName() + " 进入4");
                }
            }
        }
    }
}

释放锁

下面操作会释放锁

1.当前线程的同步方法、同步代码块执行结束

2.当前线程在同步方法、同步代码块中遇到break、return

3.当前线程在同步方法、同步代码块中出现了未处理的Error或Exception，导致异常结束

4.当前线程在同步方法、同步代码块中执行了线程对象的wait()方法，当前线程暂停，并释放锁

下面操作不会释放锁

1.线程执行同步方法或同步代码块时，程序调用了Thread.sleep()、Thread.yield()方法，
暂停当前线程的执行，不会释放锁

2.线程执行同步代码块时，其他线程调用了该线程的suspend()方法，将该线程挂起，该线程不会释放锁

3.应尽量避免使用suspend()和resume()来控制线程，方法不再推荐使用
Pioneer.93
关注
java线程基础
12-21
Java线程基础是Java编程中不可或缺的一部分，尤其在开发高并发和实时响应的应用时更为重要。线程允许程序同时执行多个任务，提高了程序的效率和响应速度。 **应用程序与进程** 应用程序是用户可以执行的软件实例，...
JAVA零基础到高级进阶特训营 JAVA多线程并发设计+Spring高级+数据库开发+JAVA基础等
08-04
这套课程既可以作为从零基础开始...课程的主要内容涉及有JAVA基础课程、JAVA多线程与并发编程、数据库开发基础和进阶、Spring Framework、Spring进阶、Spring MVC框架、Spring boot、Java常用类库、Java异常处理等等
Java线程系列详解
wang_yong_hui_1234的博客
04-15 5200
1）volatile本质是在告诉jvm当前变量在寄存器中的值是不确定的，需要从主存中读取，synchronized则是锁定当前变量，只有当前线程可以访问该变量，其他线程被阻塞住。2）volatile仅能使用在变量级别，synchronized则可以使用在变量，方法。3）volatile仅能实现变量的修改可见性，而synchronized则可以保证变量的修改可见性和原子性。4）volatile不会造成线程的阻塞，而synchronized可能会造成线程的阻塞。
Java多线程（超详细！）
一只小菜鸡
05-13 13万+
1、什么是进程？什么是线程？ 进程是:一个应用程序（1个进程是一个软件）。 线程是：一个进程中的执行场景/执行单元。 注意：一个进程可以启动多个线程。 eg.对于java程序来说，当在DOS命令窗口中输入： java HelloWorld 回车之后。 会先启动JVM，而JVM就是一个进程。 JVM再启动一个主线程调用main方法。 同时再启动一个垃圾回收线程负责看护，回收垃圾。 最起码，现在的java程序中至少有两个线程并发， 一个是垃圾回收线程，一个是执行main方法的主线程。 3、进程和线程是什么关系？
Java多线程实战-实现多线程文件下载，支持断点续传、日志记录等功能
qq_35716689的博客
03-10 25万+
本文将介绍如何通过Java来实现一个多线程下载器。作者：牵着猫散步的鼠鼠
Java 线程 基础知识总结
Zhangguohao666的博客
07-27 6319
文章目录线程基础生产消费者模型，synchronizedjoin方法+死锁（哲学家进餐问题）join和锁死锁有趣的Timer类Timer多线程的一个运行实例 初步认识下线程，线程怎么去实现（通过继承Thread或者实现Runnable接口） 线程基础 很不严谨的说，线程是什么？线程就是为了让很多个东东并发执行，大大的提高程序执行的效率啊 三个非常重要的概念： 程序：一组写好了的静态代码块（就我...
Java 多线程编程基础(详细)
一夜星尘
11-03 3万+
Java多线程编程基础进程与线程多线程实现Thread类实现多线程Runnable接口实现多线程Callable接口实现多线程多线程运行状态多线程常用操作方法线程的命名和获取线程休眠线程中断线程强制执行线程让步线程优先级设定线程的同步和锁死线程同步处理线程死锁 进程与线程 进程与线程的基本认识 进程（Process）：进程是程序的一次动态执行过程，它经历了从代码加载、执行、到执行完毕的一个完整过程；同时也是并发执行的程序在执行过程中分配和管理资源的基本单位，竞争计算机系统资源的基本单位。 线程（Thread
Java 基础 —— 线程安全
IT__learning的博客
10-31 9009
一、线程安全问题 线程安全 当多个线程访问一个对象时，如果不用考虑这些线程在运行时环境下的调度和交替执行，也不需要进行额外的同步，或者在调用方进行任何其他的协调操作，调用这个对象的行为都可以获得正确的结果，那这个对象就是线程安全的 一个程序在运行起来的时候会转换成进程，通常含有多个线程。通常情况下，一个进程中的比较耗时的操作（如长循环、文件上传下载、网络资源获取等），往往会采用多线程来解决。又比如实际生活中，银行取钱问题、火车票多个售票窗口的问题，通常会涉及到并发的问题，从而需要多线程的技术。 当进程中
java多线程（超详细）
zdl66的博客
08-14 10万+
进程就是正在运行中的程序（进程是驻留在内存中的）是系统执行资源分配和调度的独立单位每一进程都有属于自己的存储空间和系统资源注意：进程A和进程B的内存独立不共享。
Java基础：Java线程基础
TuT
04-17 3267
操作系统中线程和进程的概念 现在的操作系统是多任务操作系统。多线程是实现多任务的一种方式。 进程是指一个内存中运行的应用程序，每个进程都有自己独立的一块内存空间，一个进程中可以启动多个线程。比如在Windows系统中，一个运行的exe就是一个进程。 线程是指进程中的一个执行流程，一个进程中可以运行多个线程。比如java.exe进程中可以运行很多线程。线程总是属于某个进程，进程中的多个线程共享进程的...
Java多线程学习（吐血超详细总结）
热门推荐
Evankaka的专栏
03-14 42万+
本文主要讲了java中多线程的使用方法、线程同步、线程数据传递、线程状态及相应的一些线程函数用法、概述等。
Java多线程详解
坏蛋阿土的博客
11-06 6621
线程(thread)是操作系统能够进行运算调度的最小单位。它被包含在进程之中，是进程中的实际运作单位。一条线程指的是进程中一个单一顺序的控制流，一个进程中可以并发多个线程，每条线程并行执行不同的任务。进程(Process)是计算机中的程序关于某数据集合上的一次运行活动，是系统进行资源分配和调度的基本单位，是操作系统结构的基础。在早期面向进程设计的计算机结构中，进程是程序的基本执行实体；在当代面向线程设计的计算机结构中，进程是线程的容器。程序是指令、数据及其组织形式的描述，进程是程序的实体。
Java基础多线程.xmind
09-20
个人关于java基础多线程的思维导图总结。0积分下载。如果认为有帮助，请关注点赞，日后还有更多免费资源。
关于Java的基础线程部分
04-28
以上是Java基础线程部分的一些核心概念和用法，理解和掌握这些知识将有助于初学者构建坚实的基础，以便进一步探索Java并发编程的高级主题。在实践中，不断练习和调试多线程代码，能更好地理解和应用这些概念。
【C++刷题】力扣-#121-买卖股票的最佳时机
会写代码的饭桶
10-16 535
给定一个数组 prices，其中 prices[i] 表示第 i 天的股票价格。假设你可以在第 i 天买入并在第 j 天卖出股票（i ≤ j），设计一个算法来计算你所能获取的最大利润。注意你只能持有一股股票，并且你不能同时参与多笔交易（即在再次买入前必须卖出股票）。
基于SSM班级事务管理系统的设计
2401_87849773的博客
10-15 408
管理员账户功能包括：系统首页，个人中心，学生管理，班委管理，班会组织管理，健康档案管理，党员发展管理，党员培训管理，学生成绩管理。主要技术：Java,Spring,mybatis,mysql,jquery,html。班委账号功能包括：系统首页，学生管理，学生成绩管理，活动信息管理，班费通知管理。服务器：SpringBoot自带 apache tomcat。JDK版本：Java JDK1.8。数据库可视化工具： navicat。数据库版本： mysql5.7。开发系统：Windows。
Java安卓开发之Fragment开发（通俗易懂版）——第8章
一个脚本小子的博客
10-13 699
FragmentManager中的getSupportFragmentManager()方法不支持Activity，不论是旧版的FragmentManager还是新版的，因此我们要把继承Activity类改成继承AppCompatActivity类。
JavaWeb合集05-SpringBoot基础知识
最新发布
qq_57340195的博客
10-17 839
Autowrite ：自动装配，通过声明的数据类型来装配对应的bean对象。缺点，只能获取到一个相同类型的bean对象，如果有IOC容器里面有2个Bean对象，使用@Autowrite依赖注入就好报错。由于三层架构中，每一层都需要下次成来提供对应的方法，所有要new 下一次的对象，如果上一层的类名发送改变，那么上一层就需要修改对应的类名，如下。3、@Resource注解：通过它来代替@Autowrite注解，直接指定要注入的Bean对象，参数name的值就是要注入的Bean对象。
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值