JAVASE第十章(线程)

已于 2022-06-12 11:41:25 修改
阅读量281 收藏
点赞数 2
分类专栏： JAVASE 文章标签： java
于 2021-06-29 20:44:30 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_52173163/article/details/118341488
版权

文章目录

前言

Java 给多线程编程提供了内置的支持。一个进程中可以并发多个线程,每条线程并行执行不同的任务。多线程能满足程序员编写高效率的程序来达到充分利用CPU的目的。

一、程序 线程 进程

1.程序(program)是为完成特定任务、用某种语言编写的一组指令的集合。即指一段静态的代码。
2.线程(thread)进程可进一步细化为线程，是一个进程内部的最小执行单元，是操作系统进行任务调度最小单元，隶属于进程。
3.进程(process)就是正在执行的程序,从Windows角度讲，进程是操作系统进行资源分配的最小单位。

线程和进程的关系

1.一个进程可以包含多个线程，一个线程只能属于一个进程，线程不能脱离进程而独立运行；

2.每一个进程至少包含一个线程(称为主线程)；在主线程中开始执行程序
 java 程序的入口main()方法就是在主线程中被执行的。 
 
3.在主线程中可以创建并启动其它的线程； 

4.一个进程内的所有线程共享该进程的内存资源。

下面用一张图展示程序、线程、进程的关系。
在这里插入图片描述

二、线程

2.1 创建线程的方式

创建线程的常用方法有两种,一种是继承Thread类,重写run()方法,一种是实现Runnable接口,实现run()方法。

1.继承Thread类,重写run()方法。

public class ThreadDemo1 extends Thread{
    //在Java中要实现线程，最简单的方式就是扩展Thread类，重写其中的run方法
    @Override
    public void run() {
        for (int i = 0; i < 1000; i++) {
            System.out.println("执行了我的线程"+i);
        }
    }
}
public class Test1 {
    public static void main(String[] args) {
        ThreadDemo1 myThread=new ThreadDemo1();
        myThread.start();   //启动线程   Thread类中的run方法本身并不执行任何操作，如果我们重写了run方法，当线程启动时，它将执行 run方法
        //myThread.run();  这是调用方法,线程还没启动,不能算是多线程
        for (int i = 0; i < 1000; i++) {
            System.out.println("这是main线程里面的方法"+i);
        }
    }
}

2.实现Runnable接口,实现run()方法。

public class ThreadDemo2 implements Runnable{
    //也可以通过实现Runnable接口的方式来实现线程，只需要实现其中的run方法即可；
    @Override
    public void run() {
        for (int i = 0; i < 1000; i++) {
            System.out.println("这是我的线程"+i);
        }
    }
}
public class Test2 {
    public static void main(String[] args) {
        ThreadDemo2 myThread=new ThreadDemo2(); //创建一个任务
        Thread t1=new Thread(myThread);  //创建一个线程作为外壳，将任务包起来，
        t1.start();
        for (int i = 0; i < 1000; i++) {
            System.out.println("这是main线程里面的方法"+i);
        }
    }
}

实现Runnable的好处:

1.避免了单继承的局限性 
2.多个线程可以共享同一个接口实现类的对象，非常适合多个相同线程来处理同一份资源。

3.两种创建线程方式的区别。
1.当要进行多个线程同时访问一个共享资源时,用继承Thread类方法实现线程时,因为继承Thread类中每个对象都有自己的资源,所以要在共享资源加上static修饰,使共享资源只有一份(类所有)。
2.实现Runnable接口的好处就是多个线程可以共享一个对象,共享一个共享资源,非常适合多个相同线程来处理同一份资源。

2.2 Thread类中方法

java.lang包提供了Thread类，Thread类用于操作线程，是所以涉及到线程操作(如并发)的基础。现在我们介绍Thread类中的方法。
1.构造方法

Thread()  创建一个线程。  
Thread(Runnable target)  利用Runable对象创建一个线程。  
Thread(Runnable target, String name)  利用Runable对象创建一个线程同时指定名称。
Thread(String name)  创建一个线程并指定名称。

2.常用方法

void start()  启动线程
final void setName(String name)   设置线程名称
final String getName()   返回线程名称
final void join()   线程插队
static void sleep(long millis) 让当前线程休眠
final void setPriority(int newPriority)  设置线程优先级
static Thread currentThread() 返回对当前正在执行的线程对象的引用

public class Test3 {
    public static void main(String[] args) {
        ThreadDemo3 myThread=new ThreadDemo3();   //创建一个任务
        Thread t1=new Thread(myThread,"李四");  //利用Runnable对象创建一个线程，并指定该线程的名称
        Thread t2=new Thread(myThread,"张三");
        //优先级较高的线程有更多获得CPU的机会，反之亦然；
        // 优先级用整数表示，取值范围是1~10，一般情况下，线程的默认优先级 都是5
        // 但是也可以通过setPriority和getPriority方法来设置或返回优先级；
        /*同优先级线程组成先进先出队列，使用时间片策略
          对高优先级，使用优先调度的抢占式策略*/
        t1.setPriority(10);
        t2.setPriority(5);
        t1.start();
        t2.start();
        System.out.println(t1.getPriority());
        System.out.println(t1.getPriority());
    }
}

2.3 线程优先级

线程优先级：优先级高的线程有更多获取CPU的机会，优先级用整数表示取值范围为1-10，默认优先级为5，也可以通过setPriority方法设置优先级。

Thread类有如下3个静态常量来表示优先级

1.MAX_PRIORITY：取值为10，表示最高优先级。 
2.MIN_PRIORITY：取值为1，表示最底优先级。 
3.NORM_PRIORITY：取值为5，表示默认的优先级。

调度策略：即依据什么原则挑选程。

1.时间片策略：为每个任务分配一个时间片
2.抢占式：高优先级的线程抢占CPU

Java的调度方法

1.同优先级线程组成先进先出队列，使用时间片策略 
2.对高优先级，使用优先调度的抢占式策略

三、线程状态和分类

3.1线程状态

线程状态：线程是有生命周期的，在不同的周期中处于不同的状态。
在这里插入图片描述

线程的状态：
1.新建:当一个线程被创建时处于新建状态。
2.就绪:新建的线程被start()后,进入了就绪状态。
3.运行:当就绪的线程被调度并获得CPU资源时,便进入运行状态。
4.阻塞:在某种特殊情况下，被人为挂起或执行输入输出操作时,让出CPU并临时中止自己的执行,进入阻塞状态 。
5.死亡:线程完成了它的全部工作或线程被提前强制性地中止或出现异常导致结束。

注意:
1.当线程调用start()方法后,没有马上进入运行状态,而是进入就绪状态,当获得cpu资源时才能进入运行状态。
2.myThread.run() 这是调用方法,线程还没开始启动，不能算是多线程。

3.2线程分类

Java中的线程分为两类：用户线程和守护线程

例如：任何一个守护线程都是整个JVM中所有非守护线程的保姆： 只要当前JVM实例中尚存在任何一个非守护线程没有结束，守护线程就全部工作；只有当最后一个非守护线程结束时，守护线程随着JVM一同结束工作。

public class Defend extends Thread{
    @Override
    public void run() {
        while(true){
            System.out.println("我是守护线程我在守护着你");
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }
}

public class DefendTest {
    public static void main(String[] args) {
        //只要当前JVM实例中尚存在任何一个非守护线程没有结束，守护线程就全部工作；
        // 只有当最后一个非守护线程结束时，守护线程随着JVM一同结束工作。
        Defend d1=new Defend();
        d1.setDaemon(true);  //变成守护线程
        DefendedThread d2=new DefendedThread();
        d2.start();
        d1.start();
    }
}

守护线程的作用是为其他线程的运行提供便利服务，守护线程最典型的应用就是 GC (垃圾回收器)，它就是一个很称职的守护者。

注意:设置线程为守护线程必须在启动线程之前，否则会跑出一个 IllegalThreadStateException异常

四、多线程的概念

多线程：一个程序中可以同时运行多个不同的线程来执行不同的任务。
何时需要多线程:

1.程序需要同时执行两个或多个任务。
2.程序需要实现一些需要等待的任务时，如用户输入、文件读写操作、 网络操作、搜索等。 
3.需要一些后台运行的程序时。

多线程的优缺点

优点：
1.提高程序的响应。
2.提高CPU的利用率。
3.改善程序结构，将复杂任务分为对个线程，独立运行。
缺点：
1.线程也是程序，所以线程需要占用内存，线程越多占用内存也越多； 
2.多线程需要协调和管理，所以需要CPU时间跟踪线程； 
3.线程之间对共享资源的访问会相互影响，必须解决竞用共享资源的问题；

注意:我们说的多线程,一定是同时开启了多个线程,例如在main线程中开启了另外一个线程。下面这个线程只有一个主线程(main),并没有创建多线程,只是进行了基本的函数调用。
在这里插入图片描述

五、线程同步

在学习线程同步之前，我们先来学习一下串行，并行和并发的概念。下面用一张图来说明三者的区别。
在这里插入图片描述
举个通俗的例子：例如我们现在在吃饭，突然来了个电话。
串行：必须等吃完饭，在去接电话，即必须按顺序完成任务。
并发：可以先去接个电话，接完电话后回来接着吃饭。
并行：边吃饭边接电话。

线程同步：多个线程同时读写同一份共享资源时，可能会引起冲突。要确保一个时间点只有一个线程访问共享资源，我们可以给共享资源加一把锁，哪个线程获取这把锁就有权利访问该共享资源。常用的方法是synchronize，常用于同步方法和同步方法块。

下面用一个模拟卖票的例子实现多线程下的同步机制。
两个窗口分别售票,票数为10张
分别使用继承Thread和实现Runnable两种方式实现

1.继承Thread实现

public class SynchronizedThread1 extends Thread {
    static int number=10;
   // static Object obj=new Object();
    public void run(){
        while(true){
            robTicket();
            if (number<=0){
                break;
            }
        }
    }
    public static synchronized  void robTicket(){
        //synchronized(同步监视器)关键字同步方法时,默认是this,一旦创建多个线程对象(不加static的情况),同步对象有多个,相当于没锁住
        //加static修饰后,同步对象变为线程类(类只有一个)
        if(number>0){
            try {
                Thread.sleep(2000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println(Thread.currentThread().getName()+"正在出售:"+number);
            number--;
        }
    }    /*//方法2:写在代码块中
    public void run() {
        while(true){
            synchronized (obj){   //使用synchronized(同步监视器)关键字同步方法或代码块。
                //同步监视器可以是任何对象,必须唯一,保证多个线程获得是同一个对象
                if(number>0){
                    try {
                        Thread.sleep(2000);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                    System.out.println(Thread.currentThread().getName()+"正在出售:"+number);
                    number--;
                }else{
                    break;
                }
            }
        }
    }*/
}

public class SynchronizedDemo1 {
    public static void main(String[] args) {
        //同步监视器的执行过程
        // 1.第一个线程访问，锁定同步监视器，执行其中代码.
        // 2.第二个线程访问，发现同步监视器被锁定，无法访问.
        // 3.第一个线程访问完毕，解锁同步监视器.
        // 4.第二个线程访问，发现同步监视器没有锁，然后锁定并访问
        SynchronizedThread1 myThread1=new SynchronizedThread1();
        SynchronizedThread1 myThread2=new SynchronizedThread1();
        myThread1.setName("窗口1");
        myThread2.setName("窗口2");
        myThread1.start();
        myThread2.start();
    }
}

注意:
1.synchronized(同步监视器)关键字同步方法时,默认是this,一旦创建多个线程对象(不加static的情况),同步对象有多个,相当于没锁住,方法加static修饰后,同步对象变为线程类(类只有一个)。
2.使用synchronized(同步监视器)关键字同步方法或代码块。同步监视器可以是任何对象,必须唯一,保证多个线程获得是同一个对象。

2.实现Runnable接口

public class SynchronizedThread2 implements Runnable {
    //多个线程可以共享同一个接口实现类的对象，非常适合多个相同线程来处理同一份资源
    int number = 10;
    Object obj = new Object();
    @Override
    public void run() {
        while (true) {
            robTicket();
            if (number <= 0) {
              break;
            }
        }
    }
    public synchronized void robTicket() {  //ynchronized(同步监视器)关键字同步方法时,默认是this,
        // 实现Runnable接口,只有一个类的对象,所以不用加static
        try {
            Thread.sleep(1000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        if (number > 0) {
            System.out.println(Thread.currentThread().getName() + "正在售出:" + number);
            number--;
        }
    }
/*    public void run() {
        while(true){
            synchronized (obj){
                try {
                    Thread.sleep(1000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                if(number>0){
                    System.out.println(Thread.currentThread().getName()+"正在售出:"+number);
                    number--;
                }else{
                    break;
                }
            }
        }
    }*/
}
public class SynchronizedDemo2 {
    public static void main(String[] args) {
        SynchronizedThread2 t1=new SynchronizedThread2();
        //多个线程可以共享同一个接口实现类的对象，非常适合多个相同线程来处理同一份资源
        Thread myT1=new Thread(t1,"窗口1");
        Thread myT2=new Thread(t1,"窗口2");
        myT1.start();
        myT2.start();
    }
}

注意:
1.多个线程可以共享同一个接口实现类的对象，非常适合多个相同线程来处理同一份资源。
2.实现Runnable接口,只有一个类的对象,共享资源不用加static。

六、Lock(锁)

Lock：JDK 5.0开始，Java提供了更强大的线程同步机制-通过显式定义同步锁对象来实现同步。同步锁使用Lock对象充当。

java.util.concurrent.locks.Lock接口是控制多个线程对共享资源进行访问的工具。锁提供了对共享资源的独占访问，每次只能有一个线程对Lock对象加锁， 线程开始访问共享资源之前应先获得Lock对象，比较常用的是ReentrantLock。

public class LockThread {
    public static void main(String[] args) throws InterruptedException {
        //面的代码通过lock()方法先获取锁三次，然后通过unlock()方法释放锁3次，程序可以正常退出。
        ReentrantLock lock = new ReentrantLock();
        for (int i = 1; i <= 3; i++) {
            lock.lock();
        }
        for(int i=1;i<=3;i++){
            try {
            } finally {
                lock.unlock();
            }
        }
    }
}

线程死锁：不同的线程分别占用对方需要的同步资源不放弃，就形成了线程的死锁。
例如：张三拿了李四家的钥匙，李四拿了张三家的钥匙，双方都不愿意放弃，于是就卡bug了。
下面一段代码演示是死锁是怎么发生的。

public class DieSynchronizedThread extends Thread{
    static Object A=new Object();
    static Object B=new Object();
    boolean flag;
    @Override
    public void run() {
            if(flag){
                synchronized (A){
                    System.out.println(Thread.currentThread().getName()+"拿到了A");
                    synchronized (B){
                        System.out.println(Thread.currentThread().getName()+"拿到了B");
                    }
                }
            }else{
                synchronized (B){
                    System.out.println(Thread.currentThread().getName()+"拿到了B");
                    synchronized (A){
                        System.out.println(Thread.currentThread().getName()+"拿到了A");
                    }
                }

            }
    }
}
public class DieSynchronizedTest {
    public static void main(String[] args) {
        DieSynchronizedThread t1=new DieSynchronizedThread();
        DieSynchronizedThread t2=new DieSynchronizedThread();
        t1.setName("小黑");
        t2.setName("小白");
        t1.flag=true;
        t2.flag=false;
        t1.setPriority(10);
        t2.setPriority(1);
        t1.start();
        t2.start();
    }
}

七、线程通信

线程通信：多个线程通过消息传递实现相互牵制，相互调度，即线程间的相互作用。
线程通信涉及三个方法:

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

举例：两个线程交替打印1-100之间的数字

public class CommunicationThread extends Thread{
    static Object obj=new Object();
    static int number=0;
    @Override
    public void run() {
        while(true){
            synchronized (obj){
                //wait（），notify（），notifyAll（）三个方法必须使用在同步代码块或同步方法中。
                //第一次先进入一个线程,等进行完该进行的操作后调用wait()阻塞自己,然后释放同步锁,下一个线程就可以进来,进来之后由下一个进程
                //进来唤醒它,虽然已经被唤醒但无法得到同步锁,所以也只能在外面等待,这样就可以实现两个线程交互通讯并保证一次只有一个进入
                obj.notify(); //notify一旦执行此方法，就会唤醒被wait的一个线程。如果有多个线程被wait， 就唤醒优先级高的那个
                if(number<100){
                    System.out.println(Thread.currentThread().getName()+":"+(++number));
                }
                try {
                    obj.wait();  //一旦执行此方法，当前线程就进入阻塞状态，并释放同步监视器。
           } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        }
    }
}
public class CommunicationTest {
    public static void main(String[] args) {
        CommunicationThread t1=new CommunicationThread();
        CommunicationThread t2=new CommunicationThread();
        t1.setName("小黑");
        t2.setName("小白");
        t1.start();
        t2.start();
    }
}

注意:
1.wait(),notify(),notifyAll()三个方法是定义在java.lang.Object类中。
2.wait(),notify(),notifyAll()三个方法必须使用在同步代码块或同步方法中。

生产者/消费者问题

public class Count {
    int number=0;
    public synchronized void add() throws InterruptedException {
        //同步时this是一个对象,要保证一个对象这样才能保证是一把一样的锁
        if (number==0){
          this.notify();
          number++;
          Thread.sleep(2000);
            System.out.println("生产者生产了一个产品");
            System.out.println("当前柜台产品数量:"+number);
        }
        this.wait();
    }
    public synchronized  void sub() throws InterruptedException {
        if(number==1){
            this.notify();
            number--;
            Thread.sleep(2000);
            System.out.println("消费者消费了一个产品");
            System.out.println("当前柜台产品数量:"+number);
        }
        this.wait();
    }
}

public class Consumer extends Thread{
    Count c;
    public Consumer(Count c) {
        this.c = c;
    }
    @Override
    public void run() {
        while(true){
            try {
                c.sub();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }

    }
}

public class Product extends Thread{
    Count c;
    public Product(Count c) {
        this.c = c;
    }
    public void run() {
        while(true){
            try {
                c.add();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }
}

public class CountTest {
    public static void main(String[] args) {
        Count count=new Count();
        Consumer c=new Consumer(count); //两个线程共享一个对象,这样保证两个线程操作同一个变量
        Product p=new Product(count);
        c.start();
        p.start();
    }
}

即可实现生产者和消费者的有序生产消费。
在这里插入图片描述

注意:两个线程共享一个对象,这样保证两个线程操作同一个变量

八、新增创建线程方式

实现Callable接口：相比使用Runnable接口，功能更加强大，需要重写里面的call方法。
实现Callable接口优点：

1.call()方法可以有返回值，并且返回值支持泛型。
2.可以抛出异常。
3，需要借助FutureTask类，获取返回结果。

public class FutureThread implements Callable<Integer> {
    @Override
    public Integer call() throws Exception { // //相比run（）方法，1.可以有返回值 2.方法可以抛出异常 3.支持泛型的返回值
        int i=0;
        for (int j = 1; j <=1000; j++) {
            if(j%2==1){
                i+=j;
            }
        }
        return i;
    }
}
public class FutureThread2 implements Callable<Integer> {
    @Override
    public Integer call() throws Exception {
        int i=0;
        for (int j = 1; j <=1000; j++) {
            if(j%2==0){
                i+=j;
            }
        }
        return i;
    }
}
public class FutureTest {
    public static void main(String[] args) throws ExecutionException, InterruptedException {
        //实现Callable接口与使用Runnable相比，Callable功能更强大些.
        FutureThread f1=new FutureThread();
        FutureTask<Integer>t1=new FutureTask<>(f1);
        Thread myThread1=new Thread(t1);  //FutureTask继承了Runnable的类,所以可以当做Thread的参数
        FutureThread2 f2=new FutureThread2();
        FutureTask<Integer>t2=new FutureTask<>(f2);
        Thread myThread2=new Thread(t2);  //Thread需要传进去一个实现了Runnable的类,FutureTask实现了Runnable所以可以传进去
        myThread1.start();
        myThread2.start();
        System.out.println("1-1000之内的奇数和是"+t1.get());//需要借助FutureTask类，获取返回结果
        System.out.println("1-1000之内的偶数和是"+t2.get());
    }
}

注意:
1.FutureTask继承了Runnable的类。
2.Thread需要传进去一个实现了Runnable的类的参数,FutureTask实现了Runnable所以可以传进去。
3.实现Callable接口需要借助FutureTask类，获取返回结果。

总结

本章内容较多,重点掌握线程的三种创建方式以及它们之间的区别。线程的状态是线程这章的重中之重,应该熟练掌握线程各种状态之间的切换以及几个改变线程状态的方法。有效利用多线程的关键是理解程序是并发执行而不是串行执行的。例如：程序中有两个子系统需要并发执行，这时候就需要利用多线程编程。通过对多线程的使用，可以编写出非常高效的程序。

JinziH Never Give Up
关注
  • 2
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
JavaSE多线程
09-15
JavaSE的多线程特性是其强大的功能之一，它允许开发者编写能够同时处理多个任务的程序，从而提高程序的效率和响应性。在Java中，线程是程序执行的最小单位，而进程则是资源分配的基本单位。每个Java应用程序至少有一...
javase之多线程技术
最新发布
10-16
Java中的多线程技术是Java进阶学习的重要组成部分，它涉及到并发编程的理论与实践，旨在提高程序的执行效率和响应速度。以下是对多线程技术的详细解释： 1. **CPU调度算法原理** - **先来先服务（FCFS）**：按照...
JavaSE第十章.线程
qq_52163230的博客
08-04 259
目录程序进程线程线程和进程的关系创建线程1.继承Thread类2.实现Runnable接口Thread类中的常用方法放缓休眠线程优先级线程状态线程的分类用户线程守护线程多线程概念何时需要多线程优点缺点线程同步并发与并行多线程同步synchronized修饰代码块修饰方法LOCK线程死锁产生死锁的原因产生死锁的必要条件线程通信新增创建线程方式 程序进程线程 程序 程序(program),是为完成特定任务、用某种语言编写的一组指令的集合。即指一段静态的代码 进程 进程((process),就是正在执行的
第十章：线程
最爱谭先森的博客
06-15 169
第十章:线程 1.进程和线程的概述 1)进程和线程定义 进程是具有一定独立功能的程序关于某个数据集合上的一次运行活动,进程是系统进行资源分配和调度的一个独立单位. 线程是进程的一个实体,是CPU调度和分派的基本单位,它是比进程更小的能独立运行的基本单位.线程自己基本上不拥有系统资源,只拥有一点在运行中必不可少的资源(如程序计数器,一组寄存器和栈),但是它可与同属一个进程的其他的线程共享进程所拥有的全部资源. 2)进程和线程关系 一个线程可以创建和撤销另一个线程,同一个进程中的多个..
JavaSE之第十章集合框架
weixin_45603326的博客
08-05 114
JavaSE之第十章集合框架
JavaSE基础--第十章--线程
weixin_46076814的博客
01-20 173
第十章-线程 一、程序-进程-线程 程序(program):是为完成特定任务、用某种语言编写的一组指令的集合。即指一段静态代码 进程(process)：就是正在执行的程序，从Windows角度讲，进程就是含有内存和资源并安置线程的地方 线程(thread):进程可进一步细化为线程，是一个进程内部的最小执行单元(执行任务) 进程与程序的联系和分别 进程是一个动态的实体，它有自己的生命周期，反映了一个程序在一定的数据集上的运行的全部动态过程 一个进程肯定有一个与之相对应的程序，而且只有一个，而一个程序有可能
[JavaSE]第十章 Java集合
Aunean's Blog
01-20 653
10.1 Java 集合框架概述 集合、数组都是多个数据进行存储操作的结构，简称 Java 容器，此时的存储，主要指的时内存层面的存储，不涉及到持久化的存储 数组在存储多个数据方面的特点： 一旦初始化以后，其长度就确定 数据一旦定义好，其元素的类型也就确定了，我们也就只能操作指定数据类型。比如：String[] arr; int[] arr1; 数组在存储多个数据方面的缺点： 一旦初始化以后，其长度就不可修改 数组中提供的方法非常有限，对于添加、删除、插入数据等操作，非常不便，同时效率不高 获取数
JavaSE基础语法--傻瓜笔记--1215(第十章:线程)
weixin_44734518的博客
01-14 221
第十章：线程 1.程序-进程-线程 程序(program)：是为完成特定任务、用某种语言编写的一组指令的集合。即指一段静态的代码 进程((process)：就是正在执行的程序,从Windows角度讲，进程是含有内存和资源并安置线程的地方 线程(thread)：进程可进一步细化为线程，是一个进程内部的最小执行单元(执行任务) 程序与进程的联系与区别： 进程是一个动态的实体，它有自己的生命周期。反映了一个程序在一定的数据集上运行的全部动态过程。 一个进程肯定有一个与之对应的程序，而且只有一个。
JavaSE学习笔记_第十章_异常
qq_44791542的博客
09-08 109
Java SE 基础学习笔记
【Java基础系列教程】第十章 Java多线程（上）_线程创建与使用、线程生命周期
波哩个波的博客
02-27 811
一、程序、进程、线程 二、进程与线程的区别 三、Java多线程的创建（重点） 四、Java多线程的使用（重点） 五、线程的生命周期 六、面试题
JavaSE_第十四章:多线程
开心点的博客
04-05 230
JavaSE学习历程 第一章:Java初识 第二章:Java语言基础 第三章:选择结构与分支结构 第四章:循环结构 第五章:方法/函数 第六章:数组 第七章:面向对象 第八章:三大特性 第九章:三个修饰符 第十章:接口 第十一章:常用类 第十二章:集合 第十三章:异常 第十四章:多线程 1 什么是线程 1.1 进程 进程:程序是静止,只有真正运行的时的程序,才能被称为进程. 特点: 单核CPU在任何时间点上只能运行一个进程 宏观并行,微观串行. 1.2 线程 线程：又称轻量级进程（Light We
JavaSE异常与多线程
06-04
入门级笔记，适合查漏补缺。
JavaSE 多线程资料
04-06
JavaSE 多线程是Java编程中至关重要的概念，它涉及到如何在单个程序中同时执行多个任务，从而提升程序的效率和响应性。在Java中，线程是程序执行的最小单位，与进程一同构成了操作系统的基础运行模型。 首先，线程...
JavaSe知识总结：多线程.xmind
10-19
思维导图：含括多线程概念，线程创建开启方式，线程安全，线程状态及常见问题
不知道JAVA多态哪里用过?多态的应用场景
qq_52173163的博客
02-04 4141
多态是JAVA的三大特性之一,多态在JAVA中也有广泛的应用,本文简单介绍了JAVA中几种多态的应用场景供大家学习。本文简单的介绍了多态的几种应用场景,包括常用类的方法、HttpServletRequest的实现以及数据库驱动接口。接口与多态密切相关,由于接口可以有多个不同的实现类所以常常表现出多态性。...
你真的知道String不可变的原因吗？答案在这
qq_52173163的博客
06-10 3347
以往我们对String不可变的认识大多都停留在内部有一个final修饰的数组,但是这个说法不太严谨,这篇文章来揭示一下String到底为什么不可变。 String 不可变的表现就是当我们试图对一个已有的对象 “abcd” 赋值为 “abcde”，String 会新创建一个对象。 从下图我们看出str的哈希值发生了变化,即str指向了其他的地址。 即原来的"abcd"没有发生变化,这就是String不可变的体现。 为什么String不可变呢?下面给出一种通用的答案。 String内部用 final 修饰
理解sleep()和wait()
qq_52173163的博客
01-20 2219
文章目录前言一、sleep()二、wait()三、sleep()和wait()的区别总结 前言 sleep方法和wait方法是两个非常容易混淆的概念，也是经常会被问到的一个问题。本文介绍了两个方法各自的特点以及两个方法之间的区别，有助于我们理解并且区分。 一、sleep() sleep()方法是Thread类里面的方法，调用该方法会导致当前线程休眠 下面以一个案例来讲解sleep方法的具体使用场景 package com.ffyc.thread.day1; public class Example
JAVASE第一章(概述)
qq_52173163的博客
03-16 1991
JAVASE第一章 文章目录前言一、为什么学习java二、Java语言发展史三、Java语言的特点1、跨平台性2、开源(开放源代码,免费)四、Java语言体系结构1、JavaSE2、JavaEE3、JavaME五、Java语言的运行机制六、Java运行环境的安装与配置七、.开发第一个java程序 前言 Java是一种简单的，跨平台的，面向对象的，分布式的，解释的，健壮的安全的，结构的中立的，可移植的，性能很优异的多线程的，动态的语言。当1995年SUN推出Java语言之后，全世界的目光都被这个神奇的语言
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

打赏作者

JinziH Never Give Up

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

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

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

打赏作者

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

抵扣说明：

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

余额充值