Java基础知识总结-多线程

已于 2022-03-02 17:52:00 修改
阅读量142 收藏
点赞数
分类专栏： Java 文章标签： java 开发语言 后端
于 2020-08-11 16:15:33 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_45328533/article/details/107831618
版权
多线程

进程：资源分配的基本单位，在程序执行时创建。
线程：资源分配的最小单位，是进程的一个执行流，一个进程由多个线程组成。

并发和并行：并发是指多个事件在一个时间段发生（交叉进行），并行是指多个事件在同一时间发生（同时进行）。

线程的调度方式
分时调度：所有线程轮流使用CPU的使用权，平均分配每个线程占用CPU的时间。
抢占式调度：优先让优先级高的线程使用CPU，如果线程的优先级相同，那么会随机选择一个（线程随机性），java使用的方式。

创建线程的两种方式
继承Thread类：用一个类继承Thread类然后重写run方法，用方法来完成线程任务。启动方式是在运行线程中可以实例化一个线程实例，然后调用start方法就可以开启创建的线程。（一个线程对象只能启动一次。）缺点：因为Java是单一继承制，无法满足线程类需要继承别的类来完成线程任务的情况。
实现Runable接口：用一个类实现Runable接口然后重写run方法，用方法完成线程任务。也是实例化一个线程类对象后，再将线程类对象作为参数示例化一个Thread类对象，然后调用start方法来开启线程。不过这种方法因为是使用的接口，所以并不会有单继承的烦恼。

//第一种
public class RunnableImpl extends Thread{
  @Override 
  public void run() {
		   for (int i = 0; i < 20; i++) { 
		   System.out.println(Thread.currentThread().getName()+"-->"+i); 
		   }
  	  }
   }
//第二种
public class RunnableImpl implements Runnable {
  @Override 
  public void run() {
		   for (int i = 0; i < 20; i++) { 
		   System.out.println(Thread.currentThread().getName()+"-->"+i); 
		   }
  	  }
   }

线程的随机性问题：执行主方法的线程我们称为主线程，当主线程完成一个线程对象的执行，并让主线程后子线程都进行控制台打印时我们会发现有可能出现随机打印的情况，这种情况产生的原因就是我们之前说的线程的调度方式，当我们两个线程都运行时相当于cpu有两条执行的通道，而两个线程都会抢夺cpu的执行权，所有cpu在随机访问两个线程之间切换就会出现随机打印的问题。

常用的关于线程信息的方法

//获取当前线程的名称
Thread.currentThread().getName()
//获取当前线程的优先级
Thread.currentThread().getPriority()
//设置线程的名称
//第一种
MyThread mt = new MyThread(); 
mt.setName("小强"); mt.start();
//第二种
new MyThread("旺财").start();

并发时的线程安全问题
出现的原因：多个线程操作同一个资源时，导致操作结果错误。
哪些问题：
1.可见性 ：当一个公共资源被一个线程修改后，别的线程要能够看见它的修改。
分析：拿公共静态资源变量举例，如果主线程在拿到公共资源副本后对齐进行while循环判断其实没有对副本的操作并且高效的调用副本，所以这个副本就不会刷新，而在这个时候子线程对这个公共资源进行了操作，也获取了副本并且操作完成后返回给了静态资源区的公共资源。及时此时的公共资源满足了主线程跳出while循环的条件也不会跳出循环，因为主线程的副本没有刷新。

2.有序性 ：程序的执行顺序按照代码的顺序执行。
分析 ：有时候编译器在编译代码时可能会对一部分代码进行重排，重排的代码一般都是在单线程情况下不影响结果的，例如 a=1; b=2; 这种，但是在多线程环境下可能会影响别的线程的执行结果，例如a,b两个全局变量在别的线程中也在时候，此线程当一个值改变后丢失了CPU的控制权，开始执行另一个线程，如果没有重排则另一个线程操作的是改变后的a值，但是重排后操作的是改变后的b值。

3.原子性 ：对资源操作时要么全部执行完成并且执行过程不会被任何元素打断，要么就都不执行。
分析：首先我们知道线程对公共资源的操作是三个部分。首先获取公共资源的副本，然后对副本进行操作，然后把结果返回给公共资源。在这个操作过程中可能随时丢掉cpu的使用权，所以可能出现一个线程拿到了副本，操作了数据然后还没返回丢失了cpu使用权，这个时候另一个线程拿到cpu使用权后开始拿副本操作数据，返回给公共资源，完成后第一个线程再次得到cpu使用权直接把数据写会，这样就会出现丢失了第二个线程对数据的操作情况，从而导致结果错误。

线程安全问题的解决方法
1.volatile关键字
此关键字作用在被多个线程操作的公共资源上其作用就是当公共资源被改变后使它的所有副本失效。并且修饰的变量在编译时不会发生顺序改变。所以可以解决可见性和有序性问题。但是还是同一情况，假如我们的回写过程是

int i；
tem = i + 1;
i = tem;

此时因为i被改变所以第一个线程i的值无效了，但它拿到cpu时会执行 i= tem 还是会导致结果错误。所以无法解决原子性问题。

2.原子类（CAS乐观锁）

提供的原子类
1). java.util.concurrent.atomic.AtomicInteger：对int变量进行原子操作的类。
2). java.util.concurrent.atomic.AtomicLong：对long变量进行原子操作的类。
3). java.util.concurrent.atomic.AtomicBoolean：对boolean变量进行原子操作的类
可以使用这些原子类来操作数据保证解决原子性问题，它是通过CAS乐观锁的方式来解决的

CAS乐观锁：它叫乐观锁是因为总是认为自己在访问数据操作是不会有别的线程也访问数据，所以这个加锁方式是允许自己操作的时候别的线程也操作的，但是当这个线程要进行数据返回前会进行一次判断，它会新获得一个副本并和自己的操作副本进行比较，如果不一样则说明在操作数据期间有别的线程也对数据进行了操作，这时它会用新的副本再操作一次数据再进行比较，如果一样则说明没有别的线程在这期间操作数据所以之间把数据写回。

CAS乐观锁的ABA问题：假如我们第一次取值副本为A然后有别线程在判断之前将公共资源修改为了B然后又修改回了A，那么开始的线程在判断时依旧会认为没有别的线程修改过公共资源而直接写回。（有人可能觉的反正都是A，应该没区别，可是如果是个栈对象，最开始的A已经出栈了这时栈口的A不是最开始的A了就会有问题。）所以解决办法是给每次对资源的修改增加一个版本号，判断时不再比较值，而是比对版本号。

代码级的线程安全问题
举例说明：银行存取款问题

public class Account {
    //公共资源同一张卡 有卡号 余额
    private String name ;
    private double money;

    public Account(String name, double money) {
        this.name = name;
        this.money = money;
    }
    getter...setter....
 }

//取钱的线程类
public class Take implements Runnable{
    private Account account;
    private int takeMoney;

    public Take(Account account, int getMoney) {
        this.account = account;
        this.takeMoney = getMoney;
    }
    @Override
    public void run() {
        if (takeMoney <=account.getMoney()){
            System.out.println(Thread.currentThread().getName()+"取钱"+ takeMoney);

            try {
                Thread.sleep(1000);
                System.out.println("剩余"+(account.getMoney()- takeMoney));
                 account.setMoney(account.getMoney()- takeMoney);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }
}

//测试类
public class Test1   {
    public static void main(String[] args) throws InterruptedException {
        Account account = new Account("卡1",800);
        new Thread(new Take(account,800)).start();
        new Thread(new Take(account,800)).start();
    }
}
//控制台打印
Thread-0取钱800
Thread-1取钱800
剩余0.0
剩余0.0

我们在这个例子中可以看见结果是错误的，预想的结果是第一次取钱取完后没有钱了，第二次取完钱后是-800块才对，但是因为取的是副本所以流程就变成了第一个线程执行，获得公共类的副本，然后在还没有操作回写改变公共值时第二个线程执行，获得公共副本，此时两个线程取的值都为800，所以其中一个线程执行完成回写公共资源为0，另一个并不会再重新获取公共资源副本而是把自己操作的结果0直接覆盖上个线程的值来改变公共资源。

解决办法
1.同步代码块
synchronized{
}
同步代码块中写需要保持原子性的部分在这个例子中

        synchronized(account) {
        if (takeMoney <=account.getMoney()){
            System.out.println(Thread.currentThread().getName()+"取钱"+ takeMoney)
                System.out.println("剩余" + (account.getMoney() - takeMoney));
                account.setMoney(account.getMoney() - takeMoney);
            }
        }

原理：拿到CPU执行权的线程在代码执行到同步代码块时会判断同步代码块上是否有锁对象，如果有就获得锁对象并进入同步代码块执行，此时就算丢失CPU控制权别的线程执行到这也拿不到锁对象，直到有锁对象的线程执行完同步代码块内容然后释放锁对象别的线程才能获取锁对象进入执行。

2.同步方法
就是在方法上添加一个synchronized（）修饰来让这个方法变成同步方法，基本等同于同步代码块。

3.Lock锁

简单的例子 具体的使用和synchronized 的区别可以去https://www.cnblogs.com/handsomeye/p/5999362.html学习。

//1.在成员位置创建Lock接口的实现类对象
 private ReentrantLock rl = new ReentrantLock();
 //2.在可能出现线程安全问题的代码前,使用lock方法获取锁对象
  rl.lock();
  //3.在线程安全问题的代码后释放锁对象
  rl.unlock();

常用的并发包
List集合的CopyOnWriteArrayLis。
set集合的CopyOnWriteArraySet。
Map集合的ConCurrentHashMap。
这几个并发包都是线程安全的，可以在多线程环境下保证线程安全。

多线程协作

1.CountDownLatch计数器
CountDownLatch使一个或多个现在在别的线程结束后完成操作。
构造方法

public CountDownLatch(int count)// 初始化一个指定计数器的CountDownLatch对象

常用方法

public void await() throws InterruptedException// 让当前线程等待
public void countDown()	// 计数器进行减1

实现

//需要等待的线程
public class MyThreadAC extends Thread { 
		private CountDownLatch countDownLatch;
	    public MyThreadAC(CountDownLatch countDownLatch) {
			  this.countDownLatch = countDownLatch;
	   }
   		@Override
   		 public void run() { 
  			 System.out.println("A"); 
 		  try {
 			  countDownLatch.await();//等待计数器归0执行 
   			} catch (InterruptedException e) {
   				 e.printStackTrace();
   			  }
     System.out.println("C"); 
     } 
   }

//执行后计数器减一的线程
public class MyThreadB extends Thread { 
		private CountDownLatch countDownLatch; 
		public MyThreadB(CountDownLatch countDownLatch) {
				 this.countDownLatch = countDownLatch;
		 }
		 @Override
		public void run() {
				  System.out.println("B");
  					 countDownLatch.countDown();//让计数器的值-1
   		 } 
  }

//运行的主线程
public static void main(String[] args) throws InterruptedException { 
		CountDownLatch cdl = new CountDownLatch(1);//创建1个计数器 
		new MyThreadAC(cdl).start(); 
		Thread.sleep(1000); 
		new MyThreadB(cdl).start();
 }

2.CyclicBarrier
他可以让多个线程执行到一个步骤后进行等待，直到所有线程都进入等待状态再执行莫一个线程。
构造方法

public CyclicBarrier(int parties, Runnable barrierAction)// 用于在线程到达屏障时，优先执行barrierAction，方便处理更复杂的业务场景

常用方法

public int await()// 每个线程调用await方法告诉CyclicBarrier我已经到达了屏障，然后当前线程被阻塞

实现

//等待的线程
public class PersonThread extends Thread {
    private CyclicBarrier cb;

    public PersonThread(CyclicBarrier cb) {
        this.cb = cb;
    }

    @Override
    public void run() {
        try {
            Thread.sleep((int) (Math.random() * 1000));
            System.out.println(Thread.currentThread().getName()+"...来到了会场!");
            cb.await();//cb内部会将计数器 - 1
        } catch (InterruptedException e) {
            e.printStackTrace();
        } catch (BrokenBarrierException e) {
            e.printStackTrace();
        }
    }
}

//等待后执行的线程
public class MeetingThread extends Thread{
    @Override
    public void run() {
        System.out.println("线程都执行了，该我执行了!");
    }
}

//主线程
public class Demo {
    public static void main(String[] args) {
        //等待5个线程执行完毕，再执行MeetingThread
        CyclicBarrier cb = new CyclicBarrier(5,new MeetingThread());
        PersonThread  p1 = new PersonThread(cb);
        PersonThread  p2 = new PersonThread(cb);
        PersonThread  p3 = new PersonThread(cb);
        PersonThread  p4 = new PersonThread(cb);
        PersonThread  p5 = new PersonThread(cb);
        p1.start();
        p2.start();
        p3.start();
        p4.start();
        p5.start();
    }
}

3.Semaphore
控制线程的数量
构造方法

public Semaphore(int permits)						permits 表示许可线程的数量
public Semaphore(int permits, boolean fair)			fair 表示公平性，如果这个设为 true 的话，下次执行的线程会是等待最久的线程

常用方法

public void acquire() 表示获取许可  lock
public void release() 表示释放许可  unlock

实现

//创建一个可以同时供两个人参观的教室类
package Demo14Semaphore;

import java.util.concurrent.Semaphore;

public class ClassRoom {
    private Semaphore semaphore = new Semaphore(2);
    public void info() throws InterruptedException {
        semaphore.acquire();//开始同步
        System.out.println(Thread.currentThread().getName()+"..来到了教室!");
        Thread.sleep(2000);//参观2秒
        System.out.println(Thread.currentThread().getName()+"..离开了教室!");
        semaphore.release();//结束同步
    }
}

//创建线程参观教室
public class StudentThread extends Thread{
    private ClassRoom classRoom;

    public StudentThread(ClassRoom classRoom) {
        this.classRoom = classRoom;
    }

    @Override
    public void run() {
        try {
            classRoom.info();//学生进入教室
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }
}
//主线程模拟多个游客（线程）参观
public class Demo {
    public static void main(String[] args) {
        //创建一个教室
        ClassRoom classRoom = new ClassRoom();
        //循环创建5名学员
        for (int i = 0; i < 5; i++) {
            new StudentThread(classRoom).start();
        }
    }
}

4.Exchanger
实现线程之间的数据交互
构造方法

public Exchanger()

常用方法

public V exchange(V x) 参数传递给对方的数据,返回值接收对方返回的数据

实现

//线程A
public class ThreadA extends Thread {
    private Exchanger<String> exchanger;

    public ThreadA(Exchanger<String> exchanger) {
        this.exchanger = exchanger;
    }

    @Override
    public void run() {
        System.out.println("线程A开始执行");
        System.out.println("线程A给线程B100元,并从线程B得到一个电影票");
        String result = null;
        try {
            result = exchanger.exchange("100元");
            System.out.println("线程A得到的东西:"+result);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }
}

//线程B
public class ThreadB extends Thread {
    private Exchanger<String> exchanger;

    public ThreadB(Exchanger<String> exchanger) {
        this.exchanger = exchanger;
    }

    @Override
    public void run() {
        System.out.println("线程B开始执行");
        System.out.println("线程B给线程A一张电影票,并从线程A得到100元钱");
        String result = null;
        try {
            result = exchanger.exchange("电影票");
            System.out.println("线程B得到的东西:"+result);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }
}

//测试类
public class Demo {
    public static void main(String[] args) {
        //创建Exchanger对象
        Exchanger<String> exchanger = new Exchanger<>();
        new ThreadA(exchanger).start();
        new ThreadB(exchanger).start();
    }
}

线程A开始执行
线程A给线程B100元,并从线程B得到一个电影票
线程B开始执行
线程B给线程A一张电影票,并从线程A得到100元钱
线程A得到的东西:电影票
线程B得到的东西:100元


//还可以设置等待的时间
  try {
            result = exchanger.exchange("100元",5, TimeUnit.SECONDS);
            System.out.println("线程A得到的东西:"+result);
        } catch (InterruptedException e) {
            e.printStackTrace();
        } catch (TimeoutException e) {
            System.out.println("5秒钟没等到线程B的值，线程A结束！");
        }

线程池
线程池简单说就是放线程的容器，在接受到线程任务后分配线程完成任务，在任务完成后将线程归还。线程带来的好处
1、降低了资源消耗，减少了任务执行需要创建和销毁线程消耗的资源
2、提升了响应速度，没有了创建线程的过程，任务直接执行。
3、提高了线程的可管理性。线程是需要限制创建的，要不然回消耗系统资源也会降低系统的稳定性。

线程池可以执行Runnable线程和Callable线程
区别也就是Runnable线程只能执行run 方法，而Callable可以有返回值返回值类型在创建时确定，并用future对象接受，调用起get方法获得。

例子

//求输入1+到输入n的和
public class Demo03ThreadPool {
    public static void main(String[] args) throws ExecutionException, InterruptedException {
        //1.使用Scanner获取一个整数
        System.out.println("请输入一个整数:");
        int n = new Scanner(System.in).nextInt();
        //2.使用Executors线程池工厂类中的静态方法newFixedThreadPool创建一个指定线程数量的线程池ExecutorService
        ExecutorService es = Executors.newFixedThreadPool(3);
        //3.创建Callable接口的实现类对象,重写call方法,设置线程任务(计算1到n的和,并返回)
        //4.使用线程池ExecutorService中的方法submit,传递线程任务(Callable),submit方法会在线程池中获取一个线程,执行线程任务
        Future<Integer> future = es.submit(new Callable<Integer>() {
            @Override
            public Integer call() throws Exception {
                //计算1到n之间的和
                //定义一个变量,初始值为0,记录累加求和
                int sum = 0;
                //使用for循环获取1到n之间的数字
                for (int i = 1; i <= n; i++) {
                    //累加求和
                    sum += i;
                }
                //把和返回
                return sum;
            }
        });
        System.out.println("计算1到"+n+"之间的和为:"+future.get());
    }
}

创建线程
Executors（jdk1.5并发包）提供四种线程池（具体可以看https://blog.csdn.net/qq_38408785/article/details/91383959）
newCachedThreadPool创建一个可缓存线程池，如果线程池长度超过处理需要，可灵活回收空闲线程，若无可回收，则新建线程。
newFixedThreadPool 创建一个定长线程池，可控制线程最大并发数，超出的线程会在队列中等待。
newScheduledThreadPool 创建一个定长线程池，支持定时及周期性任务执行。
newSingleThreadExecutor 创建一个单线程化的线程池，它只会用唯一的工作线程来执行任务，保证所有任务按照指定顺序(FIFO, LIFO, 优先级)执行

再有就是通过ThreadPoolExecutor，它是Execurors 的底层实现。
具体的方式如下。

创建线程的参数
在这里插入图片描述
线程池的执行任务的流程
1.首先任务接受后判断现在的线程数是否达到了核心线程数，如果没达到就创建线程来执行任务，如果达到了就进入队列等待。
2.在进入队列时如果队列已经满了，那么就判断线程数是否达到了最大线程数，如果没有达到就创建线程执行任务，如果达到了就执行拒绝策略。

在这里插入图片描述
拒绝策略
在这里插入图片描述
1.当拒绝任务时抛出异常处理（默认）
2.当任务满时删除队列中最前面的任务再重新请求
3.直接抛弃请求不抛出异常
4.由请求线程自己来进行任务处理

死锁
就是在两个线程互相等待对方的锁对象的情况。

public class Die1 {
public static String lock = "1";
public static String lock1 = "2";
    public static void main(String[] args) throws InterruptedException {


        new Thread(new Runnable() {
            @Override
            public void run() {
                synchronized (lock1){
                    System.out.println("子线程进入了第一层的锁");
                    try {
                        Thread.sleep(2000);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                    synchronized (lock){
                        System.out.println("子线程进入了第二层的锁");
                    }
                }
            }
        }).start();
        synchronized (lock){
            System.out.println("主线程进入了第一层的锁");
            Thread.sleep(2000);
            synchronized (lock1){
                System.out.println("主线程进入了第二层的锁");
            }
        }


    }
}

主线程进入了第一层的锁
子线程进入了第一层的锁

线程状态
在这里插入图片描述
wait
无限等待，但会释放监视器（锁）为了让监视器通过别的线程调用notify方法唤醒

sleep
有限等待，不会释放监视器（锁）

   Object类中的方法:
        void wait()
          在其他线程调用此对象的 notify() 方法或 notifyAll() 方法前，导致当前线程等待。
        void notify()
          唤醒在此对象监视器(锁对象)上等待的单个线程。
        void notifyAll()
          唤醒在此对象监视器上等待的所有线程。
    注意:
        一般都在同步代码块中调用wait或者notify方法
        一般都是使用锁对象调用wait和notify方法
            锁对象-->wait()-->Thread-0线程-->等待
            锁对象-->notify()-->Thread-1线程-->唤醒
学习没个头阿
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
Java知识点总结大全(三) -- 多线程.xmind
12-17
Java知识点总结大全(三) -- 多线程.xmind，其他里面还有基础知识，面向对象，io,集合，网络，sql的总结
线程池应用实例
weixin_42191545的博客
09-11 387
利用线程池拷贝大文件（包含文件夹和文件） 回顾：怎样读取目录，创建目录以及识别是目录文件还是普通文件？ opendir() mkdir() readdir() 获取文件属性----stat()函数具体使用可以百度 准备：如何实现递归遍历显示文件夹下所有子文件夹下的文件？ （递归就是函数自己调用自己！） #include <stdio.h> #include <sys/types.h> #include <dirent.h> #include <stdlib
java基础知识学习--多线程
tomas的博客
03-13 749
一、如何创建线程 1、继承Thread类 class CreateThread extends Thread{ @Override public void run() { System.out.println("启动线程"); } } 2、通过实现Runnable接口 class CreateThread1 implements Runnable{ @Override public void run() { System.out.
08-多线程
Wuyikkk的博客
04-28 218
一、线程 1.说明 1. 线程，是程序内部的一条执行路径。 2. 如果一个进程同一时间并行执行多个线程，则为支持多线程。 3。 线程作为调度和执行的单位，每个线程拥有独立的运行栈和程序计数器(pc)，线程切换的开销小。 4. 一个进程中的多个线程共享相同的内存单元/内存地址空间它们从同一堆中分配对象，可以访问相同的变量和对象。这就使得线程间通信更简便、高效。但多个线程操作共享的系统资源可能就会带...
java 多线程 boolean,java中Atomic类之AtomicBoolean 多线程处理
weixin_29802461的博客
03-14 425
类在java.util.concurrent.atomic包下，有AtomicBoolean , AtomicInteger, AtomicLong, AtomicReference等类，它们的基本特性就是在多线程环境下，执行这些类实例包含的方法时，具有排他性，即当某个线程进入方法，执行其中的指令时，不会被其他线程打断，而别的线程就像自旋锁一样，一直等到该方法执行完成，才由JVM从等待队列中选择一...
Java基础知识--多线程
inferno_devil的博客
03-12 156
1.多线程介绍及运行原理 进程： -正在运行的程序。确切的来说当一个程序进入内存运行即变成一个进程，进程是处于运行过程中的 程序，并且具有一定独立功能，进程是系统进行资源分配和调度的一个独立单位。 -进程是正在运行的程序，进程负责给程序分配内存空间，而每一个进程都是由程序代码组成的，这些代码在进程中执行的流程就是线程。 线程： -线程是进程中的一个执行单元，负责当前进程中程序的执行，一个进程...
Java基础知识总结（2021版）
学Java，找哪吒
01-09 25万+
前言 大家好，我是素小暖，2012年毕业，2016年通过培训转行java开发，今天2021年1月9日，转行之路跌跌绊绊，蓦然回首，已经满满的4年工作经验了？但感觉知识还是相当的匮乏，没自信，也许是努力程度还不够吧。很感谢CSDN，因为是它给了我学习的动力，之前写了一篇记录CSDN博客访问量的文章，也许大家感觉很幼稚，但真的很有用，很有效果，仿佛磕了药一样，努力学习，进步。 2020年，是我较为成功的一年，工作上，跳了槽，涨了工资；学习上，啃了几本名著（Effective Java、重构 改善既.
Java基础知识总结（超详细整理）
热门推荐
龙源IT 的博客
07-17 25万+
Java语言的特点，1.面向对象(OOP)就是Java语言的基础，也是Java语言的重要特性。面向对象的概念：生活中的一切事物都可以被称之为对象，生活中随处可见的事物就是一个对象，我们可以将这些事物的状态特征（属性）以及行为特征（方法）提取并出来，并以固定的形式表示。 2.简单好用，Java语言是由C和C++演变而来的，它省略了C语言中所有的难以理解、容易混淆的特性（比如指针），变得更加严谨、简洁、易使用。 3.健壮性、Java的安全检查机制，将许多程序中的错误扼杀在摇蓝之中。 另外，在
头歌Educoder——Java高级特性 - 多线程练习题
赵士杰——成功并非一蹴而就，而是在持之以恒的努力中逐渐实现。
03-24 1万+
文章目录第1关：顺序输出任务描述相关知识（略）编程要求测试说明代码示例第2关：售票窗口任务描述相关知识（略）编程要求测试说明代码示例Station.javaTask.java 第1关：顺序输出 任务描述 本关任务：利用多线程相关知识控制三个线程，依照先后顺序顺序输出。 相关知识（略） 编程要求 请仔细阅读右侧代码，在 Begin-End 区域内进行代码补充，使线程依照先后顺序依次输出JavaThread+线程名。 提示：我们知道线程的执行结果是随机的，什么时候执行线程是看哪一个线程抢占到了CPU的资源，现在
【Java基础知识 1】Java入门级概述
学Java，找哪吒
09-25 14万+
CSDN最强Java专栏，包含全部Java基础知识点、Java8新特性、Java集合、Java多线程、Java代码实例，理论结合实战，实现Java的轻松学习。
零基础Java入门课程-多线程
07-01
该课程基于最新的java14平台，由浅入深的详细讲解了java集合框架的知识。帮助Java初学者掌握JSE相关知识。
Java基础知识点总结.docx
04-03
Java学习更是如此，知识点总结目录如下： 目录 一、 Java概述 3 二、 Java语法基础 5 数据类型 5 运算符号 14 语句 15 函数 15 方法重载（Overloadjing）与重写（Overriding） 16 数组 17 总结 18 三、 常见关键字 ...
JAVA多线程入门基础知识
02-22
必知必会的多线程入门基础知识
java多线程基础知识
01-25
java多线程基础知识
jar包增量更新分析
junlaiyan的专栏
05-16 133
借助jdeps分析出jar包的增量文件
jdk8新特性----Lambda表达式
w_t_y_y的博客
05-11 436
Java的Lambda表达式是Java 8引入的一个特性，它支持函数式编程，允许将函数作为方法的参数或返回值，从而简化了匿名内部类的使用，并提供了对并行编程的更好支持。
CMS垃圾回收器为什么被移除
m0_54187478的博客
05-10 517
由于上述缺点，加上需要将资源投入到更现代垃圾回收器的开发和优化上，Oracle决定从Java 9开始标记CMS为废弃，并在后续版本中完全移除CMS。这些新的收集器旨在提供更低的停顿时间和更高的性能，同时减少配置和维护的复杂性。当它在垃圾收集周期内无法足够快地回收内存时，会退回到一种需要完全暂停所有应用线程的老年代收集模式，这与它设计的初衷相违背。：CMS使用的标记-清除算法会导致较多的内存碎片。：CMS需要更多的CPU资源来执行垃圾回收的并发阶段，而且它在运行时对系统资源的利用也较为激进。
java导出excel动态加载多sheet多复杂表头
weixin_43931108的博客
05-14 199
java导出excel动态加载多sheet多复杂表头
Android Model引入其他aar包 导致无法打包成aar
最新发布
qq_27400335的博客
05-16 232
Android Model引入其他aar包 导致无法打包成aar

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值