Java基础编程-多线程

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

本文全文参考视频https://www.bilibili.com/video/av48144058内容编写

1、基本概念：程序、进程、线程

  • 程序(programm)：是为完成特定任务、用某种语言编写的一组指令的集合。即指一段静态的代码。
  • 进程(process)：程序的一次执行过程，或是正在运行的一个程序。
    • 说明：进程作为资源分配的单位，系统在运行时会为每个进程分配不同的内存区域
  • 线程(thread)：进程可进一步细化为线程，是一个程序内部的一条执行路径。
    • 说明：线程作为调度和执行的单位，每个线程拥独立的运行栈和程序计数器(pc)，线程切换的开销小。
      在这里插入图片描述

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

  • 内存结构
    在这里插入图片描述
  • 并行与并发的理解
    • 并行：多个CPU同时执行多个任务。比如：多个人同时做不同的事。
    • 并发：一个CPU(采用时间片)同时执行多个任务。比如：秒杀、多个人做同一件事

2、线程的创建和使用

  • 有两种方法来创建一个新的执行线程。
2.1.新增线程方式一： 声明一个类是类Thread的子类。这类应重写类Thread的run方法。子类的一个实例可以被分配和启动。
  • 例如，一个线程计算素数大于规定值可以写成如下：
     class PrimeThread extends Thread {
         long minPrime;
         PrimeThread(long minPrime) {
             this.minPrime = minPrime;
         }

         public void run() {
             // compute primes larger than minPrime
              . . .
         }
     }
  • 下面的代码将创建一个线程并开始运行：
     PrimeThread p = new PrimeThread(143);
     p.start();

如果直接调用run()方法，则不会创建新的线程，比如 p.run();

  • 如果再启动一个线程，必须重新创建一个Thread子类的对象，调用此对象的start().
p.start();
p.start(); // 报错 IllegalThreadStateException
2.2.新增线程方式二：创建一个线程是声明一个类实现Runnable接口的其他方式。该类实现run方法。那类的一个实例可以分配，作为一个参数传递Thread时创建，并开始。
  • 同样的例子在这个其他风格看起来像以下：
     class PrimeRun implements Runnable {
         long minPrime;
         PrimeRun(long minPrime) {
             this.minPrime = minPrime;
         }

         public void run() {
             // compute primes larger than minPrime
              . . .
         }
     }
  • 下面的代码将创建一个线程并开始运行：
     PrimeRun p = new PrimeRun(143);
     new Thread(p).start();
2.3.Thread类的常用方法
1.start():启动线程并执行相应的run()方法

2.run():子线程要执行的代码放入run()方法中

3.currentThread():获取当前的线程 //静态方法

4.getName():获取子线程的名称

5.setName():设置子线程的名称

6.yield():调用此方法的线程释放当前CPU的执行权

7.join()：在子线程1中调用线程2的join()方法，表示当执行到此方法时，线程1停止执行(阻塞)

8.sleep(long l):显示让当前线程睡眠(毫秒 1s = 1000ms)

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

10.getPriority():获取优先级,默认是5,最小是1,最大是10

11.setPriority():改变线程的优先级

12.线程通信的方法：
wait():等待
notify():唤醒等待的线程
notifyAll()：唤醒所有等待的线程
2.4.线程的优先级

在这里插入图片描述

优先级高，并不会一定先执行，只是执行的概率变高。
高优先级线程–抢占–低优先级线程

例子：创建三个窗口卖票，总票数为100张
/**
 * @Author Jerry
 * @Description //例子：创建三个窗口卖票，总票数为100张
 * @Date 19:52 2020/3/21
 * @Param
 * @return
 **/
public class ThreadTest01 {
    public static void main(String[] args) {
        Window w1 = new Window("窗口一");
        Window w2 = new Window("窗口二");
        Window w3 = new Window("窗口三");

        w1.start();
        w2.start();
        w3.start();
    }
}

class Window extends Thread {
    private static int ticket = 100;

    public Window(String name) {
        super(name);
    }

    @Override
    public void run() {

        while (true) {
            if (ticket > 0) {
                System.out.println(getName() + ":卖票，票号为：" + ticket);
                ticket--;
            } else {
                break;
            }
        }
    }
}

在这里插入图片描述

  • 该例子目前的写法存在线程安全问题。在学习线程的同步后就能解决

3、线程的生命周期

在这里插入图片描述

  • 生命周期关注两个概念：状态、相应的方法
  • 关注：状态a–>状态b:哪些方法执行了（回调方法）
    • 某个方法主动调用：状态a–>状态b
  • 阻塞：临时状态，不可以作为最终状态；死亡：最终状态。

线程的6种状态

  • NEW(初始)：线程被创建后尚未启动。
  • RUNNABLE(运行)：包括了操作系统线程状态中的Running和Ready，也就是处于此状态的线程可能正在运行，也可能正在等待系统资源，如等待CPU为它分配时间片。
  • BLOCKED(阻塞)：线程阻塞于锁。
  • WAITING(等待)：线程需要等待其他线程做出一些特定动作（通知或中断）。
  • TIME_WAITING(超时等待)：该状态不同于WAITING，它可以在指定的时间内自行返回。
  • TERMINATED(终止)：该线程已经执行完毕。
    在这里插入图片描述

4、线程的同步

案例背景

例子：创建个窗口卖票，总票数为100张.使用实现Runnable接口的方式
1.问题：卖票过程中，出现了重票、错票 -->出现了线程的安全问题
2.问题出现的原因：当某个线程操作车票的过程中，尚未操作完成时，其他线程参与进来，也操作车票。
3.如何解决：当一个线程a在操作ticket的时候，其他线程不能参与进来。直到线程a操作完ticket时，其他线程才可以开始操作ticket。这种情况即使线程a出现了阻塞，也不能被改变。

4.1.方式一：同步代码块
   synchronized(同步监视器){
      //需要被同步的代码
   }
说明
  • 1.操作共享数据的代码，即为需要被同步的代码。 -->不能包含代码多了，也不能包含代码少了。
  • 2.共享数据：多个线程共同操作的变量。比如：ticket就是共享数据。
  • 3.同步监视器，俗称：锁。任何一个类的对象，都可以充当锁。
要求
  • 多个线程必须要共用同一把锁。
public class ThreadTest01 {
    public static void main(String[] args) {
        Window w1 = new Window("窗口一");
        Window w2 = new Window("窗口二");
        Window w3 = new Window("窗口三");
        w1.start();
        w2.start();
        w3.start();
    }
}
class Window extends Thread {
    private static int ticket = 100;
    private static Object object = new Object();
    
    public Window(String name) {
        super(name);
    }
    @Override
    public void run() {
        while (true) {
            synchronized (object){
                try {
                    Thread.sleep(100);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                if (ticket > 0) {
                    System.out.println(getName() + ":卖票，票号为：" + ticket);
                    ticket--;
                } else {
                    break;
                }
            }
        }
    }
}

补充：在实现Runnable接口创建多线程的方式中，我们可以考虑使用this充当同步监视器。
在继承Thread类创建多线程的方式中，慎用this充当同步监视器，考虑使用当前类充当同步监视器。

4.2.方式二：同步方法
    @Override
    public void run() {
        show();
    }

    private static synchronized void show() {
        while (true) {
            try {
                Thread.sleep(100);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            if (ticket > 0) {
                System.out.println(Thread.currentThread().getName() + ":卖票，票号为：" + ticket);
                ticket--;
            } else {
                break;
            }
        }
    }
  1. 同步方法仍然涉及到同步监视器，只是不需要我们显式的声明。
  2. 非静态的同步方法，同步监视器是：this --》Runnable private synchronized void show()
    静态的同步方法，同步监视器是：当前类本身 --》Thread private static synchronized void show()
面试题：使用同步机制将单例模式中的懒汉式改写为线程安全的
public class BankTest {
}
class Bank {
    public Bank() {
    }
    
    private static Bank instance = null;

    // 方式一：同步方法
//    public static synchronized Bank getInstance() {
//        if (instance == null){
//            instance = new Bank();
//        }
//        return instance;
//    }
    // 方式二：同步代码块
//    public static Bank getInstance() {
//        synchronized (Bank.class) {
//            if (instance == null) {
//                instance = new Bank();
//            }
//            return instance;
//        }
//    }
    // 方式二性能优化：
    public static Bank getInstance() {
        if (instance == null) {
            synchronized (Bank.class) {
                if (instance == null) {
                    instance = new Bank();
                }
            }
        }
        return instance;
    }
}
4.3.方式三：Lock(锁)— JDK5.0新增
class LockWindow implements Runnable{
    private int ticket = 100;

    // 1.实例化ReentrantLock对象
    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);
                    ticket--;
                } else {
                    break;
                }
            } finally {
                // 3.调用解锁方法
                lock.unlock();
            }
        }
    }
}
面试题：Java是如何解决线程安全问题的，有几种方式？并对比几种方式的不同
  • 答：同步代码块（synchronized）、同步方法（synchronized）、Lock锁
面试题：synchronized和Lock方式解决线程安全问题的对比

在这里插入图片描述

练习题

在这里插入图片描述

package hjl.study.thread;

public class AccountTest {
    public static void main(String[] args) {
        Account acct = new Account(0);
        Customer c1 = new Customer(acct);
        Customer c2 = new Customer(acct);

        c1.setName("储户一");
        c2.setName("储户二");

        c1.start();
        c2.start();
    }
}

class Customer extends Thread {
    private Account acct;

    public Customer(Account acct) {
        this.acct = acct;
    }

    @Override
    public void run() {
        for (int i = 0; i < 3; i++) {
            acct.deposit(1000);
        }


    }
}

class Account {
    private double balance;

    public Account(double balance) {
        this.balance = balance;
    }

    // 存钱
    public synchronized void deposit(double amt){
        if (amt > 0) {
            balance += amt;

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

            System.out.println(Thread.currentThread().getName()+":存钱成功。余额为："+balance);
        }
    }
}

5、线程的通信

5.1.线程通信涉及到的三个方法：
  • wait():一旦执行此方法，当前线程就进入阻塞状态，并释放同步监视器。
  • notify():一旦执行此方法，就会唤醒被wait的一个线程。如果有多个线程被wait，就唤醒优先级高的那个。
  • notifyAll():一旦执行此方法，就会唤醒所有被wait的线程。
5.2.说明：
  • 1.wait()，notify()，notifyAll()三个方法必须使用在同步代码块或同步方法中。
  • 2.wait()，notify()，notifyAll()三个方法的调用者必须是同步代码块或同步方法中的同步监视器。否则，会出现IllegalMonitorStateException异常
  • 3.wait()，notify()，notifyAll()三个方法是定义在java.lang.Object类中。
面试题
  • sleep() 和 wait()的异同？
    • 相同点：一旦执行方法，都可以使得当前的线程进入阻塞状态。
    • 不同点：
      • 1）两个方法声明的位置不同：Thread类中声明sleep() , Object类中声明wait()
      • 2）调用的要求不同：sleep()可以在任何需要的场景下调用。 wait()必须使用在同步代码块或同步方法中
      • 3）关于是否释放同步监视器：如果两个方法都使用在同步代码块或同步方法中，sleep()不会释放锁，wait()会释放锁。
案例一：使用两个线程打印1-100
/**
 * 线程通信例子：使用两个线程打印1-100
 * 线程一、线程二交替打印
 **/
class Number implements Runnable {

    private int number = 1;

    @lombok.SneakyThrows
    @Override
    public void run() {

        while (true) {
            synchronized (this) {

                // 唤醒一个线程（优先级高的先唤醒）
                notify();

                if (number <= 100) {
                    Thread.sleep(10);
                    System.out.println(Thread.currentThread().getName() + ":" + number);
                    number++;

                    // 使得调用如下wait()的线程进入阻塞状态
                    wait();

                } else {
                    break;
                }
            }
        }

    }
}

public class CommunicationTest {
    public static void main(String[] args) {
        Number number = new Number();
        Thread t1 = new Thread(number);
        Thread t2 = new Thread(number);
        t1.setName("线程一");
        t2.setName("线程二");
        t1.start();
        t2.start();

    }
}
案例二：线程通信的应用：生产者/消费者问题

在这里插入图片描述

import lombok.SneakyThrows;

/**
 * 线程通信的应用：生产者/消费者问题
 *
 * 分析：
 *      1.是否有多线程问题？是，生产者线程，消费者线程
 *      2.是否有共享数据？是，店员（或产品）
 *      3.如何解决线程的安全问题？同步机制，有三种方法
 *      4.是否涉及线程内通信？是
 */
public class ProductTest {
    public static void main(String[] args) {
        Clerk clerk = new Clerk();

        Producter p1 = new Producter(clerk);
        p1.setName("生产者1");

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

    }
}
/**
 * 店员
 **/
class Clerk{
    private int productCount = 0;

    // 生产产品
    @SneakyThrows
    public synchronized void produceProduct() {
        if (productCount<20){
            productCount++;
            System.out.println(Thread.currentThread().getName()+":开始生产第"+productCount+"个产品");
            // 生产者生产产品后，就可以唤醒消费者消费产品
            notify();
        } else {
            wait();
        }
    }

    // 消费产品
    @SneakyThrows
    public synchronized void consumeProduct() {
        if (productCount>0){
            Thread.sleep(100);
            System.out.println(Thread.currentThread().getName()+":开始消费第"+productCount+"个产品");
            productCount--;
            // 消费者消费产品后，产品减少，就可以唤醒生产者生产
            notify();
        } else {
            wait();
        }
    }
}
/**
 * 生产者
 **/
class Producter extends Thread{

    private Clerk clerk;

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

    @Override
    public void run() {
        System.out.println(this.getName()+":开始生产产品...");
        while (true){
            clerk.produceProduct();
        }

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

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

    @Override
    public void run() {
        System.out.println(this.getName()+":开始消费产品...");
        while (true){
            clerk.consumeProduct();
        }

    }
}

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

6.1.新增线程方式三：实现Callable接口

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

理解案例一：
import java.util.concurrent.Callable;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.FutureTask;

// 1.创建一个实现Callable的实现类
class NumThread implements Callable {

    // 2.实现call方法，将此线程需要执行的操作声明在call()中
    @Override
    public Object call() throws Exception {
        int sum = 0;
        for (int i = 0; i < 100; i++) {
            if (i % 2 == 0) {
                sum += i;
            }
        }
        return sum;
    }
}

public class ThreadNew {
    public static void main(String[] args) throws ExecutionException, InterruptedException {
        // 3.创建Callable实现类对象
        NumThread numThread = new NumThread();
        // 4.将此Callable实现类对象传递到FutureTask构造器中，创建FutureTask对象
        FutureTask futureTask = new FutureTask<>(numThread);
        // 5.启动线程
        //public class FutureTask<V> implements RunnableFuture<V>
        //public interface RunnableFuture<V> extends Runnable, Future<V>
        //public class Thread implements Runnable {
        new Thread(futureTask).start();
        
        // 6.获取Callable中call()方法的返回值
        // get()返回值即为FutureTask构造器参数Callable实现类重新的call的返回值
        Object sum = futureTask.get();
        System.out.println("总和为："+sum);
    }
}
6.2.新增线程方式四：使用线程池

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

理解案例一：
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.ThreadPoolExecutor;

public class ExecutorsTest {
    public static void main(String[] args) {
        // 1.提供指定线程数量的线程池
        ExecutorService service = Executors.newFixedThreadPool(10);

        // 设置线程池的属性
        ThreadPoolExecutor service1 = (ThreadPoolExecutor) service;
        service1.setCorePoolSize(15); // 核心池的大小
        service1.setMaximumPoolSize(20); // 最大线程数

        // 2.执行指定线程的操作。
        service.execute(new NumberThread()); // 适合使用于Runnable
        service.execute(new NumberThread1()); // 适合使用于Runnable
//        service.submit(); // 适合使用于Callable

        // 3.关闭连接池
        service.shutdown();
    }
}
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);
            }
        }
    }
}
菜菜程序猿Garry
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
JAVA-多线程 所有文件
01-09
JAVA-多线程 所有文件
【168】Java调用EXE并利用多线程接收EXE的输出流
zhangchao19890805的专栏
06-09 643
Java调用EXE并利用多线程接收EXE的输出流
Java程序测试之线程的使用
weixin_30699741的博客
03-17 142
package thread_test; class A implements Runnable { public void run() { while(true) { System.out.println("AA"); } } } clas...
java线程_Java线程的概念
weixin_35944650的博客
02-12 61
Java线程的概念下一节>和其他多数计算机语言不同，Java内置支持多线程编程(multithreaded programming)。多线程程序包含两条或两条以上并发运行的部分。程序中每个这样的部分都叫一个线程(thread)，每个线程都有独立的执行路径。因此，多线程是多任务处理的一种特殊形式。你一定知道多任务处理，因为它实际上被所有的现代操作系统所支持。然而，多任务处理有两种截然不同的类型...
Java基础——线程的基本概念
weixin_47208494的博客
04-20 132
线程基础 进程与线程 进程 简介：一个正在进行的程序 从内存的角度看，当程序运行时，系统会为其分配一定的运行空间(运行内存上)，这片空间就是进程 线程 简介：代码的一条执行路径 1、Java程序在运行时自带一条线程，这条线程称为主线程(main线程) 2、一个进程中可以有多个线程 3、从宏观上考虑多个线程是同时执行的，但从微观上考虑，多个线程在抢夺CPU执行权，谁抢夺谁执行一句代码，然后重新抢夺，所以微观考虑他们是交替执行的，因为抢夺Cpu执行权的速度很快，所以说宏观上是同时执行的。 4、除在主线程外
Java线程详解
观千剑而后识器，操千曲而后晓声。
08-16 8644
Java线程：概念与原理 一、操作系统中线程和进程的概念 现在的操作系统是多任务操作系统。多线程是实现多任务的一种方式。 进程是指一个内存中运行的应用程序，每个进程都有自己独立的一块内存空间，一个进程中可以启动多个线程。比如在Windows系统中，一个运行的exe就是一个进程。   线程是指进程中的一个执行流程，一个进程中可以运行多个线程。比如java.exe进程中可以运行很多线
Java核心基础编程精讲-多线程
06-21
从零开始学习Java核心基础编程精讲 本章主要为大家介绍多线程，让学员快速熟悉基本操作系统简介，java多线程，线程相关操作和线程同步、生命周期等。课件在最后一节旁边下载，有什么问题可私信我，祝学习愉快
零基础Java入门课程-多线程
07-01
该课程基于最新的java14平台，由浅入深的详细讲解了java集合框架的知识。帮助Java初学者掌握JSE相关知识。
Java深入核心-多线程编程实战
06-18
对于一个 Java 程序员而言，能否熟练掌握多线程编程是判断他优秀与否的重要标准之一。因为并发编程是 Java 语言中最为晦涩的知识点，它涉及操作系统、内存、CPU、编程语言等多方面的基础能力，更为考验一个程序员的...
java并发编程：线程基础
08-09
本资源致力于向您介绍 Java 并发编程中的线程基础，涵盖了多线程编程的核心概念、线程的创建和管理，以及线程间通信的基本方法。通过深入学习，您将建立扎实的多线程编程基础，能够更好地理解和应用多线程编程。 多...
多线程-用JAVA写一个多线程程序，写四个线程，其中二个对一个变量加1，另外二个对一个变量减1...
代码说-Let code talk
03-18 447
[code="java"] public class IncDecThread { private int j=10; /* * 题目:用JAVA写一个多线程程序，写四个线程，其中二个对一个变量加1，另外二个对一个变量减1 * 两个问题： * 1、线程同步--synchronized * 2、线程之间如何共享同一个j变量--内部类 */ p...
Java线程
热门推荐
sunyingboaini的博客
06-20 1万+
线程的使用
一文搞定Java并发编程面试考点
weixin_33979745的博客
01-25 3864
2019独角兽企业重金招聘Python工程师标准>>> ...
JAVA中的多线程的理解和运用（Thread类）
quyuquan2014的博客
09-08 342
进程 讲到多线程，在这里我想说说进程。进程大家用过电脑的人都晓得，我们打开任务管理器，里面就有这各种各样的进程，在计算机上运行着。书面上来说：进程是一个正在执行中的程序，每一个进程执行都有一个执行的程序，该顺序是一个执行的路径，或者是一个控制单元。 线程 就是进程中的一个独立的控制单元，线程在控制着进程的执行。也就是说，每个进程之中，就比如说QQ，我不止和一个人聊天，如果我和A,B,C同...
java多线程系列——（1）线程的概念及三种实现方式
BodyCoding
07-13 134
线程和进程是我们常见的两个专业名词， 进程是指当前系统正在运行的应用程序，是系统资源调度的基本单位，在单核CPU时代，同一时间只能有一个进程运行。 线程是在进程下进一步划分的更小的调度单位，它是系统分配处理器时间资源的基本单元。一个进程中可以有多个线程并发执行，但是线程的“并发执行”只是相对的，并不是说多个线程同时在执行，而是交替执行。 线程和进程类似，都有它们的状态，线程分别有五种状态： 新建...
Java多线程（一）——多线程基本概念、线程创建方式
yubo_830的博客
05-30 328
Java多线程（一） 一、程序、进程、线程基本概念 程序：是为完成特定任务，用某种语言编写的一组指令的集合，即指一段静态的代码，静态对象。 进程：是程序的一次执行过程，或是正在运行的一个程序，是一个动态的过程，有它自身的产生，存在和消亡的过程。 线程：线程是操作系统能够进⾏运算调度的最⼩单位，它被包含在进程之中，是进程中的实际运作单位，可以使⽤多线程对 进⾏运算提速。 二、并发、并行基本概念 并行：多个CPU同时执行多个任务。多个cpu实例或者多台机器同时执行一段处理逻辑。 并发：一个CPU（采用时间片）同
JAVA程序设计：线程的概念
weixin_33719619的博客
02-15 79
一、前言 二、什么是线程 线程，一般指的是进程中执行任务的流程。 每个进程开启后都会拥有独立的内存空间，一个进程可以执行多个线程，而多个线程共享一个进程的内存空间。 线程只能是进程的一部分，它能够满足我们提高内存的使用效率。 三、线程的生命周期 线程是一个动态执行的过程，它有自己的生命周期。 线程的五种状态： 新建(New)...
java学习笔记_线程
今生今世的专栏
05-03 1026
一、Java线程：概念与原理 1、操作系统中线程和进程的概念 现在的操作系统是多任务操作系统。多线程是实现多任务的一种方式。进程是指一个内存中运行的应用程序，每个进程都有自己独立的一块内存空间，一个进程中可以启动多个线程。比如在Windows系统中，一个运行的exe就是一个进程。线程是指进程中的一个执行流程，一个进程中可以运行多个线程。比如java.exe进程中可以运行很多
java线程的基本概念与使用
java编程学习_java基础教程_booyzhang的博客
05-13 127
1、什么是进程 程序是指令和数据的有序集合，其本身没有任何运行的含义，是个静态的概念。而进程是程序在处理机上的一次执行过程，它是一个动态的概念。进程是一个具有一定独立功能的程序，一个实体，每一个进程都有它自己的地址空间。 2、进程的状态 进程执行时的间断性，决定了进程可能具有多种状态。事实上，运行中的进程具有以下三种基本状态。 1)就绪状态(Ready) 2)运行状态( Running) 3)阻塞状态(Blocked) 3、线程 线程实际上是在进程基础之上的进步划分， -个进程启动之后，里面的若干程序又可以
Java高级特性 - 多线程基础（3）线程同步
最新发布
09-01
在Java的多线程编程中，线程同步是一个非常重要的概念。它用来确保多个线程在访问共享资源时不会产生冲突或竞争条件。在Java中，有几种方式可以实现线程同步，其中之一就是使用synchronized关键字。 synchronized...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值