Java多线程操作

最新推荐文章于 2024-05-08 12:20:31 发布
最新推荐文章于 2024-05-08 12:20:31 发布
阅读量80 收藏
点赞数
分类专栏： Java基础 文章标签： java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_51409098/article/details/126291205
版权

目录

一、程序、进程、线程的理解

1、程序(programm)

2、进程(process)

3、线程(thread)

二、并行与并发

1、单核CPU与多核CPU的理解

2、并行与并发的理解

三、创建多线程的四种方式

方式一：继承Thread类的方式

方式二：实现Runnable接口的方式

方式三：实现Callable接口 --- JDK 5.0新增

方式四：线程池  --- JDK 5.0新增

四、Thread类中的常用的方法:

五、Thread的声明周期

六、线程的同步机制

1、背景

2、Java解决方案：同步机制

方式一：同步代码块

方式二：同步方法

方式三：Lock锁  --- JDK5.0新增

利弊

七、线程通信

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

2、说明

代码案例

3、sleep() 和 wait()的异同

 4、生产者消费者问题

5、小结释放锁的操作

 6、小结不会释放锁的操作

八、死锁问题

1、死锁的理解

2、死锁演示

一、程序、进程、线程的理解

1、程序(programm)

概念：为完成特定任务、用某种语言编写的一组指令的集合。即指一段静态的代码。

2、进程(process)

概念：程序的一次执行过程，或是正在运行的一个程序。

说明：进程作为资源分配的单位，系统在运行时会为每个进程分配不同的内存区域

3、线程(thread)

概念：进程可进一步细化为线程，是一个程序内部的一条执行路径。

说明：线程作为调度和执行的单位，每个线程拥独立的运行栈和程序计数器(pc)，线程切换的开销小。

 补充：

内存结构：

 进程可以细化为多个线程。

每个线程，拥有自己独立的：栈、程序计数器。多个线程，共享同一个进程中的结构：方法区、堆。

二、并行与并发

1、单核CPU与多核CPU的理解

单核CPU，其实是一种假的多线程，因为在一个时间单元内，也只能执行一个线程的任务。例如：虽然有多车道，但是收费站只有一个工作人员在收费，只有收了费才能通过，那么CPU就好比收费人员。如果某个人不想交钱，那么收费人员可以把他“挂起”（晾着他，等他想通了，准备好了钱，再去收费。）但是因为CPU时间单元特别短，因此感觉不出来。

如果是多核的话，才能更好的发挥多线程的效率。（现在的服务器都是多核的）

一个Java应用程序java.exe，其实至少三个线程：main()主线程，gc()垃圾回收线程，异常处理线程。当然如果发生异常，会影响主线程。

2、并行与并发的理解

并行：多个CPU同时执行多个任务。比如：多个人同时做不同的事。

并发：一个CPU(采用时间片)同时执行多个任务。比如：秒杀、多个人做同一件事

三、创建多线程的四种方式

方式一：继承Thread类的方式

  1. 创建一个继承于Thread类的子类
  2. 重写Thread类的run() --> 将此线程执行的操作声明在run()中
  3. 创建Thread类的子类的对象
  4. 通过此对象调用start()：①启动当前线程 ② 调用当前线程的run()

说明两个问题：

  1. 我们启动一个线程，必须调用start()，不能调用run()的方式启动线程。
  2. 如果再启动一个线程，必须重新创建一个Thread子类的对象，调用此对象的start()。
public class MyThread extends Thread{

    @Override
    public void run() {
        System.out.println("线程运行");
    }

    @Test
    public void test(){
        MyThread myThread1 = new MyThread();
        myThread1.start();

        MyThread myThread2 = new MyThread();
        myThread2.start();
    }
}

方式二：实现Runnable接口的方式

  1. 创建一个实现了Runnable接口的类
  2. 实现类去实现Runnable中的抽象方法：run()
  3. 创建实现类的对象
  4. 将此对象作为参数传递到Thread类的构造器中，创建Thread类的对象
  5. 通过Thread类的对象调用start()
public class MyThread implements Runnable{

    @Override
    public void run() {
        System.out.println("线程运行");
    }

    @Test
    public void test(){
        MyThread myThread = new MyThread();

        Thread thread1 = new Thread(myThread);
        thread1.start();

        Thread thread2 = new Thread(myThread);
        thread2.start();
    }
}

两种方式的对比：

开发中：优先选择：实现Runnable接口的方式

原因：

  1. 实现的方式没类的单继承性的局限性
  2. 实现的方式更适合来处理多个线程共享数据的情况。

相同点：

两种方式都需要重写run()，将线程要执行的逻辑声明在run()中。目前两种方式，要想启动线程，都是调用的Thread类中的start()。

方式三：实现Callable接口 --- JDK 5.0新增

  1. 创建一个实现callable的实现类
  2. 实现call方法，将此线程需要执行的操作声明在call()中
  3. 创建callable接口实现类的对象
  4. 将此callable接口实现类的对象作为传递到FutureTask构造器中
  5. 创建FutureTask的对象  将FutureTask的对象作为参数传递到Thread类的构造器中，创建Thread对象，并调用start()方法
  6. 获取callable中call方法的返回值
public class MyThread implements Callable<String>{

    @Override
    public String call() throws Exception {
        return new String("线程运行");
    }

    @Test
    public void test(){
        MyThread myThread = new MyThread();
        FutureTask<String> futureTask = new FutureTask<>(myThread);
        Thread thread = new Thread(futureTask);
        thread.start();

        String s = null;
        try {
            s = futureTask.get();
        } catch (Exception e) {
            e.printStackTrace();
        }

        System.out.println(s);
    }
}

如何理解实现Callable接口的方式创建多线程比实现Runnable接口创建多线程方式强大？

  1. call()可以返回值的。
  2. call()可以抛出异常，被外面的操作捕获，获取异常的信息
  3. Callable是支持泛型的

方式四：线程池  --- JDK 5.0新增

  1. 提供指定线程数量的线程池，设置线程池的属性
  2. 执行指定的线程的操作。需要提供实现Runnable接口或Callable接口实现类的对象
  3. 关闭连接池
  • corePoolSize：核心池的大小
  • maximumPoolSize：最大线程数
  • keepAliveTime：线程没任务时最多保持多长时间后会终止
public class ThreadPool{
    public static void main(String[] args) {
        ExecutorService service = Executors.newFixedThreadPool(10);
        ThreadPoolExecutor service1 = (ThreadPoolExecutor) service;

        service1.setCorePoolSize(5);
        service1.setKeepAliveTime(15, TimeUnit.SECONDS);

        service1.execute(new MyThread1());//适合适用于Runnable
        service1.submit(new MyThread2());//适合使用于Callable

        service1.shutdown();
    }
}
class MyThread1 implements Runnable{

    @Override
    public void run() {
        System.out.println("Runnable线程运行");
    }
}

class MyThread2 implements Callable<String>{

    @Override
    public String call() throws Exception {
        System.out.println("Callable线程运行");
        return new String("Callable线程运行");
    }
}

好处：

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

四、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():判断当前线程是否存活

线程的优先级：

  • MAX_PRIORITY：10
  • MIN _PRIORITY：1
  • NORM_PRIORITY：5  -->默认优先级

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

  • getPriority():获取线程的优先级
  • setPriority(int p):设置线程的优先级

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

线程通信：wait() / notify() / notifyAll() :此三个方法定义在Object类中的。

五、Thread的声明周期

说明：

1.生命周期关注两个概念：状态、相应的方法

2.关注：状态a-->状态b:哪些方法执行了（回调方法）
        某个方法主动调用：状态a-->状态b

3.阻塞：临时状态，不可以作为最终状态
  死亡：最终状态。 

六、线程的同步机制

1、背景

创建一个窗口卖票，总票数为100张.使用实现Runnable接口的方式

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

        Thread thread1 = new Thread(window);
        thread1.setName("窗口一");
        Thread thread2 = new Thread(window);
        thread2.setName("窗口二");

        thread1.start();
        thread2.start();
    }
}
class Window implements Runnable{

    private int ticket = 100;

    @Override
    public void run() {
        while (true){
            if(ticket > 0){
                System.out.println(Thread.currentThread().getName() + "卖票，票号为："+ ticket--);
            }else {
                break;
            }
        }
    }
}

问题：卖票过程中，出现了重票、错票 -->出现了线程的安全问题

问题出现的原因：当某个线程操作车票的过程中，尚未操作完成时，其他线程参与进来，也操作车票。

解决：当一个线程a在操作ticket的时候，其他线程不能参与进来。直到线程a操作完ticket时，其他线程才可以开始操作ticket。这种情况即使线程a出现了阻塞，也不能被改变。

2、Java解决方案：同步机制

方式一：同步代码块

class Window implements Runnable{

    private int ticket = 100;

    @Override
    public void run() {
        synchronized (this){
            while (true){
                if(ticket > 0){
                    System.out.println(Thread.currentThread().getName() + "卖票，票号为："+ ticket--);
                    try {
                        Thread.sleep(5);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }else {
                    break;
                }
            }
        }
    }
}

说明：

1.操作共享数据的代码，即为需要被同步的代码。  -->不能包含代码多了，也不能包含代码少了。
2.共享数据：多个线程共同操作的变量。比如：ticket就是共享数据。
3.同步监视器，俗称：锁。任何一个类的对象，都可以充当锁。
        要求：多个线程必须要共用同一把锁。

注意：继承Thread的方式锁对象不能是this，不然多个线程会有多个锁对象，起不到作用。可以考虑使用当前类充当监视器。

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

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

        t1.start();
        t2.start();
    }
}
class Window extends Thread{
    private static int ticket=100;
    @Override
    public void run() {
        while(true) {
            synchronized (Window.class){
                if (ticket > 0) {
                    System.out.println(getName() + ":卖票为：" + ticket);
                    ticket--;
                } else {
                    break;
                }
            }
        }
    }
}

方式二：同步方法

如果操作共享数据的代码完整的声明在一个方法中，我们不妨将此方法声明同步的。

class Window implements  Runnable{
    private int ticket=100;
    @Override
    public void run() {
        while(true) {
            show();
        }
    }
    private synchronized void show(){//同步监视器:this
        if (ticket > 0) {
            try {
                Thread.sleep(10);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println(Thread.currentThread().getName() + "卖票，票号为：" + ticket--);
        }
}

关于同步方法的总结：

1. 同步方法仍然涉及到同步监视器，只是不需要我们显式的声明。
2. 非静态的同步方法，同步监视器是：this
     静态的同步方法，同步监视器是：当前类本身

方式三：Lock锁  --- JDK5.0新增

class Window implements Runnable{
    private int ticket=100;
    //1.实例化
    private ReentrantLock lock=new ReentrantLock();

    @Override
    public void run() {

        while(true){
            //2.加锁
            lock.lock();
            try {
                if(ticket>0){
                    try {
                        Thread.sleep(100);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                    System.out.println(Thread.currentThread().getName()+": 售票，票号为： "+ticket--);
                }else{
                    break;
                }
                }finally {
                //  3.调用解锁方法：unlock()
                lock.unlock();
            }
        }
    }
}

说明：

在使用阻塞等待获取锁的方式中，必须在try代码块之外，并且在加锁方法与try代码块之间没有任何可能抛出异常的方法调用，避免加锁成功后，在finally中无法解锁。

虽然这个程序获取锁的时候在try代码块里面或者外面都没有问题，如果遇到复杂的程序就不一样了，养成一个好的习惯很重要。

  • 如果在lock方法与try代码块之间的方法调用抛出异常，那么无法解锁，造成其它线程无法成功获取锁。
  • 如果lock方法在try代码块之内，可能由于其它方法抛出异常，导致在finally代码块中，unlock对未加锁的对象解锁，它会调用AQS的tryRelease方法（取决于具体实现类），抛出IllegalMonitorStateException异常。
  • 在Lock对象的lock方法实现中可能抛出unchecked异常，产生的后果与说明二相同。 java.concurrent.LockShouldWithTryFinallyRule.rule.desc

synchronized 与 Lock的异同？

相同：二者都可以解决线程安全问题
不同：synchronized机制在执行完相应的同步代码以后，自动的释放同步监视器，Lock需要手动的启动同步lock()，同时结束同步也需要手动的实现unlock()

使用的优先顺序：

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

利弊

同步的方式，解决了线程的安全问题。---好处

操作同步代码时，只能一个线程参与，其他线程等待。相当于是一个单线程的过程，效率低。

七、线程通信

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

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

2、说明

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

代码案例

两个线程交替打印0-100

class Number implements Runnable{
    private int number=1;
    private  Object obj=new Object();
    @Override
    public void run() {
        while(true){
            synchronized (obj) {

                obj.notifyAll();

                if (number <= 100) {
                    try {
                        Thread.sleep(10);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                    System.out.println(Thread.currentThread().getName() + ":" + number);
                    number++;

                    try {
                        //使得调用如下wait()的方法的线程进入阻塞状态
                        obj.wait();
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }

                } else {
                    break;
                }
            }
        }
    }
}
public class CommubicationTest {
    public static void main(String[] args) {
        Number number=new Number();
        Thread t1=new Thread(number);
        Thread t2=new Thread(number);

        t1.setName("线程1");
        t2.setName("线程2");

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

3、sleep() 和 wait()的异同

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

不同点：

  1. 两个方法声明的位置不同：Thread类中声明sleep() , Object类中声明wait()
  2. 调用的要求不同：sleep()可以在任何需要的场景下调用。 wait()必须使用在同步代码块或同步方法中
  3. 关于是否释放同步监视器：如果两个方法都使用在同步代码块或同步方法中，sleep()不会释放锁，wait()会释放锁。

 4、生产者消费者问题

生产者(Productor)将产品交给店员(Clerk)，而消费者(Customer)从店员处取走产品，店员一次只能持有固定数量的产品(比如:20），如果生产者试图生产更多的产品，店员会叫生产者停一下，如果店中有空位放产品了再通知生产者继续生产；如果店中没有产品了，店员会告诉消费者等一下，如果店中有产品了再通知消费者来取走产品。

分析：多线程问题，共享数据，涉及线程的通信

class Clerk{

    private int productCount=0;
    //生产产品
    public synchronized void produceProduct() {
        if(productCount<20){
            productCount++;
            System.out.println(Thread.currentThread().getName()+":开始生产第"+productCount+"个产品");
            notify();
        }else{
            try {
                wait();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }
    //消费产品
    public synchronized void consumerProduct() {
        if(productCount>0){
            System.out.println(Thread.currentThread().getName()+":开始消费第"+productCount+"个产品");
            productCount--;
            notify();
        }else{
            try {
                wait();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }
}

class Producer extends Thread{//生产者

    private Clerk clerk;

    public Producer(Clerk clerk) {
        this.clerk = clerk;
    }



    @Override
    public void run() {
        System.out.println(getName()+":开始生产产品.........");
        while(true){
            try {
                Thread.sleep(10);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            clerk.produceProduct();
        }
    }
}

class Consumer extends  Thread{//消费者
    private  Clerk clerk;

    public Consumer(Clerk clerk) {
        this.clerk = clerk;
    }

    @Override
    public void run() {
        System.out.println(getName()+":开始消费产品...........");
       while(true){
           try {
               Thread.sleep(20);
           } catch (InterruptedException e) {
               e.printStackTrace();
           }

           clerk.consumerProduct();
       }
    }
}
public class ProductTest {
    public static void main(String[] args) {
        Clerk clerk=new Clerk();
        Producer p1=new Producer(clerk);
        p1.setName("生产者1");

        Consumer c1=new Consumer(clerk);
        c1.setName("消费者1");

        Consumer c2=new Consumer(clerk);
        c2.setName("消费者2");

        p1.start();
        c1.start();
        c2.start();

    }
}

5、小结释放锁的操作

 6、小结不会释放锁的操作

八、死锁问题

1、死锁的理解

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

出现死锁后，不会出现异常，不会出现提示，只是所有的线程都处于阻塞状态，无法继续。

2、死锁演示

public class ThreadTest {
    public static void main(String[] args) {
        StringBuffer s1=new StringBuffer();
        StringBuffer s2=new StringBuffer();

       new Thread(){
           @Override
           public void run() {
               synchronized (s1){
                   s1.append("a");
                   s2.append("1");

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

                   synchronized (s2){
                       s1.append("b");
                       s2.append("2");

                       System.out.println(s1);
                       System.out.println(s2);
                   }
               }

           }
       }.start();

       new Thread(new Runnable() {
           @Override
           public void run() {
               synchronized (s2){
                   s1.append("c");
                   s2.append("3");

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

                   synchronized (s1){
                       s1.append("d");
                       s2.append("4");

                       System.out.println(s1);
                       System.out.println(s2);
                   }
               }
           }
       }).start();
    }
}

我们使用同步时，要避免出现死锁

 

小鲁蛋儿
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
Java多线程
佬叁
06-21 191
目录基础概念Java的多线程多线程的好处多线程程序的注意事项线程启动线程终止yield()方法join()方法Daemon（守护）线程线程间的共享和协作线程间的共享synchronized内置锁错误的加锁和原因分析volatile，最轻量的同步机制ThreadLocal辨析与synchonized的比较ThreadLocal的使用实现解析引发的内存泄漏分析错误使用ThreadLocal导致线程不安...
Java多线程（多线程基本操作，多线程安全问题等）
2301_82242670的博客
04-15 564
(img-OW1ByR6B-1713137278101)]多线程虽然是更轻量的并发编程（相比于进程），但是线程是访问同一份内存资源，由于线程是一个抢占式执行的过程中谁先执行，谁后执行，不确定，完全却决于系统的调度。这些线程每个线程的执行顺序都是不确定的，完全取决于操作系统的调度，这里的等待线程机制就是一种确定线程先后顺序方式，确定线程的结束顺序，无法确定谁先开始，可以确定谁先结束 使用。，面试的时候我们对知识的掌握有时候很难面面俱到，把自己的思路说出来，而不是直接告诉面试官自己不懂，这也是可以加分的。
JAVA进阶学习笔记(1)：多线程
LeavingBook的博客
09-01 645
1 基本概念 1.1 程序 程序(program)是为完成特定任务、用某种语言编写的一组指令的集合。即指一段静态的代码，静态对象。 1.2 进程 进程(process)是程序的一次执行过程，或是正在运行的一个程序。是一个动态 的过程：有它自身的产生、存在和消亡的过程。——生命周期 进程作为资源分配的单位，系统在运行时会为每个进程分配不同的内存区域 。 1.3 线程 线程(thread)，进程可进一步细化为线程，是一个程序内部的一条执行路径。 1.若一个进程同一时间并行执行多个线程，就是支持多线程的 2.线程
2024年最新JAVA中的多线程操作详细剖析，java面试评语及录用意见
最新发布
2301_79098686的博客
05-08 592
千千万万要记得：多刷题！！多刷题！！之前算法是我的硬伤，后面硬啃了好长一段时间才补回来，算法才是程序员的灵魂！！！！篇幅有限，以下只能截图分享部分的资源！！（1）多线程（这里以多线程为代表，其实整理了一本JAVA核心架构笔记集）（2）刷的算法题（还有左神的算法笔记）（3）面经+真题解析+对应的相关笔记（很全面）（4）视频学习（部分）ps：当你觉得学不进或者累了的时候，视频是个不错的选择在这里，最后只一句话：祝大家offer拿到手软！！本文已被。
Java-多线程的使用
l10711097061的博客
11-12 1206
Java-多线程的使用
编程必备：JAVA多线程详解
拾一二的博客
06-14 7887
多线程已经成为一种常见的编程模式，广泛应用于各种不同类型的应用程序中。本篇博客文章中，我们将会探讨多线程编程的相关知识和技巧。通过代码示例和实际应用案例来深入了解多线程的具体实现和应用方法，帮助更好地掌握多线程编程技术，提高程序效率和性能。后期随学习深入还会补充修改。以上就是我对多线程的个人简介，后续会不断完善更新，与大家共勉。
Java多线程的使用
weixin_46102505的博客
06-10 1861
多线程的简介与学习笔记
java多线程（超详细）
热门推荐
zdl66的博客
08-14 10万+
进程就是正在运行中的程序（进程是驻留在内存中的）是系统执行资源分配和调度的独立单位每一进程都有属于自己的存储空间和系统资源注意：进程A和进程B的内存独立不共享。
java 多线程操作数据库
10-19
一个java 多线程操作数据库应用程序!!!
Java多线程编程总结
01-31
要认识多线程就要从操作系统的原理说起。以前古老的DOS操作系统（V6.22）是单任务的，还没有线程的概念，系统在每次只能做一件事情。比如你在copy东西的时候不能rename文件名。为了提高系统的利用效率，采用批处理来...
JAVA多线程操作方法实用大全
11-18
总的来说，Java多线程操作提供了丰富的控制手段，帮助开发者实现高效的并发编程。通过熟练掌握这些方法，可以更好地管理和协调多个执行流程，提高程序的性能和用户体验。在实际开发中，应根据具体需求灵活运用这些...
java多线程处理数据库数据
09-21
本主题将深入探讨如何使用Java的并发包（java.util.concurrent）来实现多线程对数据库数据的批量处理，包括增、删、改等操作。 首先，我们需要了解Java中的线程基础。线程是程序执行的最小单位，一个进程可以包含多...
Java多线程详解及示例
07-20
Java多线程编程是提升程序性能和响应性的关键技术。理解多线程的概念，掌握线程的创建、同步、通信、死锁避免等核心知识点，以及合理使用线程池，对于编写高效、稳定的并发程序至关重要。通过实践，开发者可以更好地...
JAVA多线程详解（超详细）
m0_74823434的博客
10-10 1万+
程序：开发写的代码称之为程序。程序就是一堆代码，一组数据和指令集，是一个静态的概念。进程(Process)：将程序运行起来，我们称之为进程。进程是执行程序的一次执行过程，它是动态的概念。进程存在生命周期，也就是说程序随着程序的终止而销毁。进程之间是通过TCP/IP端口实现交互的。线程(Thread)：线程是进程中的实际运作的单位，是进程的一条流水线，是程序的实际执行者，是最小的执行单位。通常在一个进程中可以包含若干个线程，当然一个进程中至少有一个线程。线程是CPU调度和执行的最小单位。注意。
一文搞懂Java多线程，讲的很详细，收藏起来慢慢看
兴趣是最好的老师，勤能补拙
07-05 2001
多线程是指在一个程序中同时执行多个线程，每个线程都有自己独立的执行路径。在多线程中，程序的执行可以同时进行多个任务，从而提高系统的资源利用率和响应性能。在传统的单线程编程模型中，程序按照顺序执行，一次只处理一个任务。这种方式在某些情况下可能会导致效率低下或者无法满足需求。而多线程通过将任务拆分为多个子任务，并且在不同的线程上同时执行，从而实现并发处理。
Java多线程（超详细）
qq_43390466的博客
05-23 2485
多任务处理有两种：基于进程进程是一种"自包容"的运行程序，有操作系统直接管理，直接运行，有自己的地址空间，每一个进程开启都会消耗内存基于进程的特点是允许计算机同时运行多个程序基于线程在一个程序中，能独立运行的程序片段叫做“线程”，线程是进程内部单一的顺序控制流一个进程拥有多个线程。多个线程共享一个进程的内存空间基于线程的多任务处理环境中，线程是最小的处理单位。
全网最全JAVA面试八股文，终于整理完了
hahazz233的博客
06-24 1万+
又到一年金三银四面试跳槽季，你准备好了吗？今天为大家整理了目前互联网出现率最高的大厂面试题，所谓八股文也就是指文章的八个部分，文体有固定格式:由破题、承题、起讲、入题、起股、中股、后股、束股八部分组成，题目一律出自四书五经中的原文。而JAVA面试八股文也就是为了考验大家的JAVA基础功底，所以强烈建议背诵全文。（1） 原子性原子性指的是一个或者多个操作，要么全部执行并且在执行的过程中不被其他操作打断，要 么就全部都不执行。（2） 可见性可见性指多个线程操作一个共享变量时，其中一个线程对变量进行修改后，其他线
Java 多线程基本使用
xiangxiongfly
05-31 492
文章目录Java 多线程基本使用进程与线程区别多线程的创建继承Thread类实现Runnable接口实现Callable接口run()与start()的区别基本使用currentThread()join()sleep()yieldwait() & notify & notifyAll()wait与sleep区别守护线程优雅中断线程interrupt()自定义变量线程同步问题不加锁synchronizedvolatileLock线程安全的集合Collectionsjava.util.concu
java 多线程操作 ConcurrentHashMap 很慢
10-25
根据提供的引用内容，我们无法得出“java 多线程操作 ConcurrentHashMap 很慢”的结论。相反，ConcurrentHashMap 是为了解决多个线程同时操作一个 HashMap 时可能出现的内部问题而生的。它的扩容机制和处理逻辑与 ...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

小鲁蛋儿

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值