狂神版多线程

最新推荐文章于 2024-07-15 22:27:18 发布
最新推荐文章于 2024-07-15 22:27:18 发布
阅读量139 收藏
点赞数
文章标签： java 多线程 设计模式 并发编程
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_45942687/article/details/117827131
版权

0、线程简介

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-Clb4UTBY-1623418097820)(…/AppData/Roaming/Typora/typora-user-images/image-20210607220944094.png)]

什么是进程？

  • 比如电脑上运行的qq、微信、酷狗音乐

什么是线程？

  • 进程中的最小执行单位就是线程，并且一个进程中至少有一个线程
  • 那什么是多线程？提到多线程这里要说两个概念，就是串行和并行

串行：其实是相对于单条线程来执行多个任务

image-20210611211010466

并行：下载多个文件，开启多条线程，多个文件同时进行下载，这里是严格意义上的，在同一时刻发生的，并行在时间上是重叠的。

image-20210611211122877

为什么要使用多线程?

1.防止阻塞主线程,提高吞吐量

2,提高资源的利用率

1、线程实现（重点）

有两种方法第一种是继承Thread类，第二种是实现Runnable接口，第三种实现Callable接口(了解)

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-6J6HO87x-1623418097824)(…/AppData/Roaming/Typora/typora-user-images/image-20210609165407447.png)]

本章核心

  • 线程就是独立的执行路径；
  • 在线程运行时，即使没有自己创建线程，后台也有多个线程，如主线程，GC线程；
  • main() 称之为主线程，为系统的入口，用于执行整个程序；
  • 在一个进程中，如果开辟了多个线程，线程的运行由调度器安排调度，调度器是与操作系统紧密相关的，先后顺序是不能任意的干预；
  • 线程会带来额外的开销，如CPIU调度时间，并发控制开销；
  • 每个线程在自己的工作内存交互，内存控制不会造成数据不一致

1、继承Thread实现

package demo01;

//创建线程方式：继承THread类， 重写run()方法，调用start开启线程
//总结：注意，线程开启不一定立即执行，由CPU调度执行

public class TestThread_01 extends Thread{
    //run方法线程体
    public void run(){
        for (int i = 0; i < 20; i++) {
            System.out.println("我wowowow---"+i);

        }
    }

    public static void main(String[] args) {

        
        //创建线程
        TestThread_01 testThread_01 = new TestThread_01();
        //调用start()  方法开启线程
        testThread_01.start();
        
        //new TestThread_01().start();


        for (int i = 0; i < 20; i++) {
            System.out.println("tatatatat--"+i);

        }
    }
}

2、接口Runnable实现

package demo01;

//创建线程方式2：事项runnable接口，重写run方法，执行线程需要丢入runnable接口实现类，调用start方法

public class TestThread_03 implements Runnable{
    //run方法线程体
    public void run(){
        for (int i = 0; i < 20; i++) {
            System.out.println("wowowow---"+i);

        }
    }


    public static void main(String[] args) {
        //main线程，主线程

//        //创建线程
//        TestThread_03 testThread_03 = new TestThread_03();
//        Thread thread = new Thread(testThread_03);
//        //调用start()  方法开启线程
//        thread.start();

        new Thread(new TestThread_03()).start();

        for (int i = 0; i < 20; i++) {
            System.out.println("tatatatat--"+i);

        }
    }
}

3、实现Callable接口(了解)

import org.apache.commons.io.FileUtils;

import java.io.File;
import java.io.IOException;
import java.net.URL;
import java.util.concurrent.*;

public class TestCallable  implements Callable <Boolean> {
    private String url;
    private String name;

    public TestCallable(String url,String name){
        this.url=url;
        this.name=name;
    }

    @Override
    public Boolean call() {
        new WebDownloder().download(url,name);
        System.out.println("下载的图片名字为："+name);
        return true;
    }

    public static void main(String[] args) {
        TestCallable t1 = new TestCallable("https://gimg2.baidu.com/image_search/src=http%3A%2F%2Fa4.att.hudong.com%2F27%2F67%2F01300000921826141299672233506.jpg&refer=http%3A%2F%2Fa4.att.hudong.com&app=2002&size=f9999,10000&q=a80&n=0&g=0n&fmt=jpeg?sec=1614909229&t=d6c07074e94ca4465416b37e14f5cef0","1.jpg");
        TestCallable t2 = new TestCallable("https://gimg2.baidu.com/image_search/src=http%3A%2F%2Fa0.att.hudong.com%2F52%2F62%2F31300542679117141195629117826.jpg&refer=http%3A%2F%2Fa0.att.hudong.com&app=2002&size=f9999,10000&q=a80&n=0&g=0n&fmt=jpeg?sec=1614909230&t=6a6a762cda2412af43daff37427ecf4e","2.jpg");
        TestCallable t3 = new TestCallable("https://gimg2.baidu.com/image_search/src=http%3A%2F%2Fa2.att.hudong.com%2F27%2F81%2F01200000194677136358818023076.jpg&refer=http%3A%2F%2Fa2.att.hudong.com&app=2002&size=f9999,10000&q=a80&n=0&g=0n&fmt=jpeg?sec=1614909230&t=7016dfebce1f6b2db216e6f84c8693b7","3.jpg");

       //创建执行服务  创建了3条线程
        ExecutorService service = Executors.newFixedThreadPool(3);

        //提交执行
        Future<Boolean> r1 = service.submit(t1);
        Future<Boolean> r2 = service.submit(t2);
        Future<Boolean> r3 = service.submit(t3);

        //获取结果
        try {
            boolean rs1 = r1.get();
            boolean rs2 = r2.get();
            boolean rs3 = r3.get();
        } catch (InterruptedException e) {
            e.printStackTrace();
        } catch (ExecutionException e) {
            e.printStackTrace();
        }
        //关闭服务
        service.shutdownNow();
    }
}

class WebDownloder{
    public void download(String url,String name) {
        try {
            FileUtils.copyURLToFile(new URL(url),new File(name));
        } catch (IOException e) {
            e.printStackTrace();
            System.out.println("Io异常");
        }
    }
}

4、静态代理模式

package demo01;

//静态v代理模式总结
//真实对象和代理对象都是要实现同一个接口
//代理对象要代理真实角色

//好处：
//    代理对象可以做到很多真是对象做不了的事情
//    真实对象专注做自己的事情
public class StacticProxy {
    public static void main(String[] args) {
        You you = new You(); //你要结婚

        new WebbingCompany(you).HappyMarry();
    }
}

interface Marry{
    void HappyMarry();
}

//真是角色，我去结婚
class You implements Marry{

    public void HappyMarry() {
        System.out.println("我要去结婚啦，是她");
    }
}

//代理角色，祝福
class WebbingCompany implements Marry{

    //代理--》真实目标角色
    private Marry target;

    public WebbingCompany(Marry target){
        this.target = target;
    }

    public void HappyMarry() {
        before();
        this.target.HappyMarry();   //真实的目标角色
        after();
    }


    private void after(){
        System.out.println("布置新房");
    }
    private void before(){
        System.out.println("洞房花烛");
    }
}

————————————————————————————————————————————————————————————

public class StacticProxy {
    public static void main(String[] args) {
        You you = new You(); //你要结婚

        
        //局部内部类
        class Race implements Runnable{
            public void run(){
                System.out.println("i love you")
            }
        }
        
        
        //匿名内部类
        new Thread (new Runnable() {
            public void run() {
                System.out.println("i love you");
            }
        }).start();
        
        //用lambda简化  条件Thread中只有一个方法
        new Thread(()->System.out.println("i love you")).start();
        new WebbingCompany(you).HappyMarry();
    }
}

2、线程状态

img

img

线程休眠 sleep()

sleep(毫秒数)指定当前线程停止的实践
sleep()存在异常InteruptedException
sleep()实践到达后线程进入就绪状态
sleep()可以模拟网络延时,倒计时等
每一个对象都有一个锁,sleep不会释放锁

线程礼让 yield()

礼让线程,让当前正在执行的线程暂停,但不阻塞
将线程从运行状态转为就绪状态
让CPU重新调度,礼让不一定成功,看CPU心情
线程强制执行 join()
Join合并线程,待此线程执行完成后,在执行其他线程,其他线程阻塞
可以想象成插队

线程优先级

  • Java提供一个线程调度来监控程序启动后进入就绪状态的所有线程，线程调度按照优先级决定应该调度那个线程来执行
  • 线程优先级用数字表示，范围从1~10.
    • Thread.MIN_PRIORITY = 1;
    • Thread.MAX_PRIORITY = 10;
    • Thread.NORM_PRIORITY = 5;
  • 使用以下方式改变或获取优先级
    • getPriority().setPriority(int XXX);

优先级低只是意味着获得调度的概率低，并不是优先级低就不会被调度。都要看CPU调度

优先级的设定建议在start()调度前

线程（daemon）线程

  • 线程分为用户线程和守护线程
  • 虚拟机必须确保用户线程执行完毕
  • 虚拟机不用等待守护线程执行完毕
  • 如，后台日记操作日记，监控内存，垃圾回收等待
Thread thread = new Thread(创建线程);
thread.setDaemon(true);    //默认是false表示用户线程，正常都是用户线程...

3、线程同步（重点）

  • 多个线程统一操作一个资源

  • 由于统一进程的多个线程共享同一块存储空间，在带来方便的同时，也带来了访问冲突，为了保证数据再方法中被访问时的正确性，在访问时加入了锁机制synchronized，当一个线程获得对象的排他锁，独占资源，其他线程等待，使用后释放锁即可. 存在以下问题：

    • 一个线程持有锁会导致其他所有需要此锁的线程挂起
    • 在多线程竞争下，加锁，释放锁会导致比较多的上下文转换和调度延时，引起性能问题；
    • 如果一个优先级高的线程等待一个优先级低的线程释放锁会导致优先级倒置，引起性能问题。（性能倒置）

    同步方法

    • 由于我们可以通过private关键字保证对象只能被方法访问，所有我们只需要针对方法提出一套机制 synchronized 关键字，两种用法：synchronized 方法 和 synchronized 块

      同步方法： public synchronized void method(int args){}

    • synchronized方法控制对“对象”的访问，每个对象对应一把锁，每个synchronized方法都必须获得调用该方法的对象的锁才行，否则线程会阻塞，方法一一旦执行，就独占该锁，知道该方法返回才释放锁，后面被阻塞的线程才能获得这个锁，继续执行

      //缺陷：若将一个大的方法申明为synchronized将会影响效率

同步方法弊端

	-  方法里面需要修改的内容才需要锁，锁的太多，浪费资源

同步块

锁的对象必须是变化的量

  • 同步块：synchronized(Obj){}
  • Obj 称之为 同步监视器
    • Obj可以是任何对行啊，但是推荐使用共享资源作为同步监视器
    • 同步方法中无需指定同步监视器，因为同步方法的同步监视器就是this，就是这个对象本身，或者是class【反射中讲解】
    • 同步监视器的执行过程：
      1. 第一个线程访问，锁定同步监视器，执行其中代码
      2. 第二个线程访问，发现同步监视器被锁定，无法访问
      3. 第一个线程访问完毕，解锁同步监视器
      4. 第二个线程访问，法相同步监视器没有锁，然后锁定并访问

死锁

  • 多个线程各自独占有一些共享资源，并且互相等待其他线程占有的资源才能运行，而导致两个或者多个线程在等待对方释放资源，都停止执行的情形，某一个同步块同时拥有“两个以上对象的锁”时，就可能发生“死锁”问题

死锁避免方法

  • 产生死锁的四个必要条件：

    1. 互斥条件：一个资源只被一个进程使用
    2. 请求与保持条件：一个进程因请求资源而阻塞时，对已获得的资源保持不放
    3. 不剥夺条件：进程已获得的资源，在未使用完之前，不能强行剥夺
    4. 循环等待条件：若干进程之间形成一种头尾相接的循环等待资源关系
    //上面列出死锁的四个必要条件，我们只要想办法破其中的人一个或多个条件就可以避免死锁发生

    Lock(锁)

    • 从JDK5.0 开始，Java提供了更强大的线程同步机制——通过显示定义同步锁对象来实现。同步锁使用Lock对象充当
    • Java.util.concurrent.locks.Lock 接口是控制多个线程对共享资源惊醒访问的工具。锁提供了对共享资源独占访问，每次只能有一个线程对Lock对象加锁，线程开是访问资源之前应先获得Lock对象
    • ReentrantLock 类实现了Lock，它拥有与synchronized相同的并发性和内存语义，在实现线程安全的控制中，比较常用的是ReentrantLock， 可以显示加锁、释放锁
    class A{
         private final ReentrantLock lock = new ReentrantLock();
         public void m(){
             lock.lock();
             try{
                 //保证线程安全的代码；
             }finally{
                 lock.unlock();
                 //如果同步代码有异常，腰间unlock写入finally语句块
             }
         }
     }

synchronized 与 Lock 的对比

  • Lock是显示锁（手动开启和关闭锁，别忘记关闭锁）synchronized是隐式锁，除了作用域自动释放
  • Lock只有代码块锁，synchronized有代码块锁和方法锁
  • 使用Lock锁，JVM将花费较少的时间来调度线程，性能更好。并且具有更好的扩展性（提供更好的子类）
  • 优先使用顺序：
    • Lock > 同步代码块（已经进入方法体，分配了相应的资源） > t同步方法 （在方法体外）

并发

  • 并发：同一个对象被多个线程同时操作

4、线程通信问题

生产者消费者模式

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-6YOFRfzU-1623418097826)(…/AppData/Roaming/Typora/typora-user-images/image-20210611124724896.png)]

线程通信—分析

这是一个线程同步问题，生产者和消费者共享一个资源，并且生产者和消费者直接按相互依赖，互为条件

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-WzCjFrqD-1623418097829)(…/AppData/Roaming/Typora/typora-user-images/image-20210611125204184.png)]

线程通信

Java提供了几个方法解决线程之间的通信问题

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-AEZR46zy-1623418097831)(…/AppData/Roaming/Typora/typora-user-images/image-20210611125309135.png)]

//注意：均Object类的方法，都只能在同步方法或者同步代码块中使用，否则会抛出异常lllegalMonitorStateExcepion
解决方式1

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-vDfcQWQ0-1623418097832)(…/AppData/Roaming/Typora/typora-user-images/image-20210611125621706.png)]

package demo01.gaoji;


//测试：生产者消费者模型——> 利用缓冲区解决：管程法

//生产者， 消费者， 产品， 缓冲区
public class TestPC {
    public static void main(String[] args) {
        SynContainer container = new SynContainer();

        new Productor(container).start();
        new Consumer(container).start();

    }
}

//产品
class Chicken{
    int id;

    public Chicken(int id) {
        this.id = id;
    }
}


//生产者
class Productor extends Thread{
    SynContainer container;
    public Productor (SynContainer container){
        this.container = container;
    }

    @Override
    public void run() {
        for (int i = 0; i < 100; i++) {
            container.push(new Chicken(i));
            System.out.println("生产了第" + i + "只鸡！！");
        }
    }

}


//消费者
class Consumer extends Thread{
    SynContainer container;
    public Consumer (SynContainer container){
        this.container = container;
    }

    @Override
    public void run() {
        for (int i = 0; i < 100; i++) {
            System.out.println("消费了第---》" + container.pop().id + "只鸡！！");
        }
    }


}



//缓冲区
class SynContainer{

    //需要一个容器大小
    Chicken[] chickens = new Chicken[10];
    //容器大小
    int count = 0;


    //生产者放入产品
    public synchronized void push(Chicken chicken){
        //如果容器满了，就需要等待消费者消费
        //chickens.length == 10
        if(count == chickens.length){
            //通知消费者消费，生产者等待
            try {
                this.wait();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }


        //如果没满，我们就需要丢如产品
        chickens[count] = chicken;
        count++;

        //可以通知消费者消费了
        this.notifyAll();

    }

    //消费者消费
    public synchronized Chicken pop(){
        //判断是否消费
        if(count == 0){
            //消费者等待   (等待生产者生产)
            try {
                this.wait();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }

        //如果可以消费
        count--;
        Chicken chicken = chickens[count];

        //吃完了， 通知生产者生产
        this.notifyAll();

        return chicken;

    }


}
解决方法2
  • 并发协作模式“ 生产者/消费者 ”——>信号灯法

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-Oc4GJ4RC-1623418097833)(…/AppData/Roaming/Typora/typora-user-images/image-20210611125804744.png)]

package demo01.gaoji;


//测试消费者消费生产者问题：信号灯法，标志位解决
class TestPC2{
    public static void main(String[] args) {
        TV tv = new TV();

        new Player(tv).start();
        new Watch(tv).start();
    }

}


//生产者-->演员
class Player extends Thread{
    TV tv;
    public Player(TV tv){
        this.tv =  tv;
    }

    @Override
    public void run() {
        for (int i = 0; i < 20; i++) {
            if(i%2==0){
                this.tv.play("开心超人");
            }else{
                this.tv.play("新闻联播来一波");
            }
        }
    }
}

//消费者-->观众
class Watch extends Thread{
    TV tv;
    public Watch(TV tv){
        this.tv =  tv;
    }

    @Override
    public void run() {
        for (int i = 0; i < 20; i++) {
            this.tv.watch();
        }
    }
}


//产品--》节目
class TV{
    //演员表演，观众等待
    //观众观看，演员等待

    String voice; //表演的节目
    boolean flag = true;


    //表演
    public synchronized void play(String voice){

        if (!flag) {
            try {
                this.wait();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }

        System.out.println("演员表演了："+voice);

        //通知观众观看
        this.notifyAll();
        this.voice = voice;
        this.flag = !this.flag;

    }

    //观看
    public synchronized void watch(){
        if (flag) {
            try {
                this.wait();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }

        System.out.println("观看了："+voice);

        //通知演员表演
        this.notifyAll();
        this.flag = !this.flag;

    }
}

使用线程池

  • 背景：经常创建和销毁、使用量特别大的资源，比如并发情况下的线程，对性能影响很大。

  • 思路：提前创建好多个线程，放入放入线程池中，使用时直接获取，使用完放回池中。可以避免频繁创建销毁、实现重复利用，类似生活的共享单车

  • 好处：

    1. 提高相应速度（减少了创建新线程的时间）
    2. 降低资源销毁（重复利用线程池中线程，不需要每次都创建）
    3. 便于线程管理（）
      • core Pool Size：核心池的大小
      • maximumPoolSize：最大线程数
      • keepAliveTime：线程没有任务时最多保持多长时间后会终止
    • JDK 5.0 起提供了线程池相关API：ExecutorService 和 Executors

  • ExecutoService：真正的线程池接口。常见子类ThreadPoolExecutor

    1. void execute(Runnable command) ：执行任务/命令，没有返回值，一般用来执行Runnable
    2. Futuresubmit(Callabletask)：执行任务，有返回值，一般又来执行Callable
    3. void shutdown()：关闭连接池

  • Executors：工具类、线程池的工厂类，用于创建并返回不同类型的线程池

5、高级主题

总结

package demo01.gaoji;

import java.util.concurrent.Callable;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.FutureTask;

//回顾总线程的创建
public class ThreadNew {
    public static void main(String[] args) {
        MyThread1 myThread1 = new MyThread1();
        myThread1.start();

        MyThread2 myThread2 = new MyThread2();
        new Thread(myThread2).start();

        FutureTask<Integer> futureTask = new FutureTask<Integer>(new MyThread3());
        new Thread(futureTask).start();

        try {
            Integer integer = futureTask.get();
            System.out.println(integer);
        } catch (InterruptedException e) {
            e.printStackTrace();
        } catch (ExecutionException e) {
            e.printStackTrace();
        }


    }


}

//1.继承Thread类
class MyThread1 extends Thread{
    @Override
    public void run() {
        System.out.println("MyThread1");
    }
}

//2.实现Runnable接口
class MyThread2 implements Runnable{
    @Override
    public void run() {
        System.out.println("MyThread2");
    }
}

//3.实现Callable接口
class MyThread3 implements Callable<Integer>{

    @Override
    public Integer call() throws Exception {
        System.out.println("MyThread3");
        return 100;
    }
}

new Thread(futureTask).start();

    try {
        Integer integer = futureTask.get();
        System.out.println(integer);
    } catch (InterruptedException e) {
        e.printStackTrace();
    } catch (ExecutionException e) {
        e.printStackTrace();
    }


}

}

//1.继承Thread类
class MyThread1 extends Thread{
@Override
public void run() {
System.out.println(“MyThread1”);
}
}

//2.实现Runnable接口
class MyThread2 implements Runnable{
@Override
public void run() {
System.out.println(“MyThread2”);
}
}

//3.实现Callable接口
class MyThread3 implements Callable{

@Override
public Integer call() throws Exception {
    System.out.println("MyThread3");
    return 100;
}

}


##
z玉无心
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
狂神说多线程详解.rar
05-06
《狂神说多线程详解》是一份深入探讨多线程技术的资源包，其中包含了对多线程编程的详尽解析。多线程是现代计算机编程中的一个重要概念，尤其在处理高性能计算、并发操作以及实时系统时，多线程技术显得尤为重要。它...
Java多线程详解（超详细）_狂神说笔记完整版_项目代码_适合小白随课程学习
08-08
Java多线程详解 在Java编程中，多线程是一种重要的技术，它使得程序能够同时执行多个任务，提高系统的效率和响应性。本教程将详细讲解Java中的多线程概念，包括线程的创建、状态、同步以及高级主题，旨在帮助初学者...
跟着狂神学多线程（附所有代码+超全资料+细节补充）
qq_40649503的博客
10-26 1410
跟着狂神学多线程 Thread类已经实现Runnable接口
狂神多线程
qq_40826814的博客
04-19 262
学习视频参考链接：https://www.bilibili.com/video/BV1V4411p7EF?p=27 线程简介 线程的实现（重点） 线程状态 线程同步（重点） 线程通信问题 高级主题（重点） 文章目录 1、线程简介 2、线程实现 2.1 继承 Thread 类，重写 run 方法 2.2 继承 Runnable 接口，创建 Tread 对象 2.3 实现 Callable 接口（了解） 2.4 Lamda 表达式 2.5 静态代理模式 3、线程的 5 种状态 .
狂神说多线程笔记
m0_51654746的博客
04-02 1008
进程与线程 进程是执行程序的一次执行过程，它是一个动态的概念，是系统资源分配的单位 通常在一个进程中可以包含若干个线程，当然一个进程中至少有一个线程，不然没有存在的一次，线程是CPU调度和执行的单位 注：很多多线程是模拟出来的，真正的多线程是指有多个cpu，即多核，如服务器，如果是模拟出来的多线程，即在一个cpu的情况下，在同一个时间点，cpu只能执行一个代码，因为切换的很快，所以就有同时执行的错觉。 多线程其实就是让不同的线程去操作同一个对象 线程创建 Thread class 继承Thread类(
狂神说多线程笔记整理
热门推荐
doris的博客
02-16 1万+
狂神说多线程笔记整理
thread.zip--狂神多线程+juc
03-18
《狂神多线程+juc》是一份针对Java并发编程深度学习的资源包，主要涵盖了Java多线程基础以及Java并发工具集（JUC）的高级应用。在Java编程中，多线程是提高程序效率、实现并发执行的重要手段，而JUC（Java ...
狂神说Java-多线程课程全部代码.rar
11-26
《狂神说Java-多线程课程全部代码》是一个涵盖了Java多线程和并发编程的实战教程资源。这个压缩包包含了一系列的示例代码（如demo01），旨在帮助开发者深入理解和掌握Java中的多线程技术及其在并发环境中的应用。 ...
Java多线程全部笔记（狂神说）.md
10-20
多线程通俗易懂，带案例笔记
配置Java开发环境
Broken_x的博客
07-10 1600
Java开发环境配置
java集合工具类
药的博客
07-12 437
【代码】java集合工具类。
java版的上门家政系统和PHP版的上门家政有什么区别？
baina666的博客
07-12 559
综上所述，Java版和PHP版的上门家政系统各有优缺点，选择哪种语言主要取决于项目的具体需求、预算、开发团队的技术栈以及未来的扩展计划等因素。同时，由于Java生态系统的复杂性和多样性，也可能需要投入更多的时间和资源来学习和掌握相关的技术和工具。Java版：Java拥有庞大的生态系统和丰富的第三方库，这为家政系统的开发和扩展提供了强大的支持。Java版：由于Java的编译执行机制和高效的垃圾回收算法，Java版家政系统通常具有更高的运行效率和更好的性能表现，尤其是在处理高并发、大数据量等复杂场景时。
Java方法练习-双色球彩票系统
T1798218285的博客
07-11 300
红色球号码从1-33中选择；蓝色球号码从1-16中选择。投注号码由6个红色球号码和1个蓝色球号码组成。三等奖 5+1 / 5+0 3000。四等奖4+1 / 4+0 200。六等奖1+1 / 1+0 5。一等奖6+1 1000w。二等奖6+0 500w。五等奖3+1 / 2+1。
基于Java技术的校园台球厅人员与设备管理系统
heye0910032的博客
07-12 549
本文介绍了一个基于Java技术和SpringBoot框架开发的校园台球厅人员与设备管理系统。该系统利用MySQL数据库进行数据存储，实现了包括首页、个人中心、用户管理、会员账号管理、会员充值管理、球桌信息管理、会员预约管理、普通预约管理、留言反馈和系统管理等多功能集成。系统设计考虑了用户友好性和操作便捷性，旨在提高校园台球厅人员与设备管理的效率和质量。本文介绍了一个基于Java技术和SpringBoot框架开发的校园台球厅人员与设备管理系统。
Java 中有哪几种基本数据类型？请分别列出它们并简述每种数据类型的特点及其在内存中的占用空间？
最新发布
liangzai215的专栏
07-15 300
在Java的世界里，数据是构建应用程序的基石。为了高效地处理这些数据，Java设计了一系列基础数据类型，它们直接映射到计算机硬件上，因此在性能和内存使用上更为高效。我们常说的Java八大基本数据类型，涵盖了整数、浮点数、字符和布尔值，下面我将一一介绍它们的特点以及在内存中的占用空间，并通过简单的代码实例来加深理解。
maven项目容器化运行之1-基于1Panel软件将docker镜像构建能力分享给局域网
qq_37372909的博客
07-15 330
docker核心功能包括镜像的构建和容器的运行，它可以开放端口将镜像构建的能力暴露。docker daeson就是docker的守护进程，开放能力是通过指定docker守护进程监听端口来实现的。后面开发人员就可以通过maven中docker插件来远程调用docker镜像构建能力了。
构建自动化的精粹：Gradle任务依赖性与执行顺序控制
liuxin33445566的博客
07-15 318
本文以"构建自动化的精粹：Gradle任务依赖性与执行顺序控制"为题，详细介绍了任务依赖性的重要性、基本配置、多个任务的依赖性、条件依赖性、错误处理、高级用法、多项目构建中的任务依赖性。随着Gradle的不断发展，我们可以预见到更多关于任务依赖性和构建自动化的高级特性的出现，这将进一步扩展Gradle的构建能力，满足更复杂的项目构建需求。任务依赖性定义了任务之间的执行关系，确保了在构建过程中，任务能够按照预期的顺序执行。任务是一个特殊的任务，它默认依赖于所有没有显式排除的任务。方法来指定任务的依赖性。
从零手写实现 nginx-27-return 指令
07-14 533
大家好，我是老马。很高兴遇到你。我们为 java 开发者实现了 java 版本的 nginx如果你想知道 servlet 如何处理的，可以参考我的另一个项目：手写从零实现简易版 tomcatminicat。
狂神说java多线程笔记
10-11
狂神在他的Java多线程笔记中，详细介绍了Java多线程的相关知识，包括线程的创建、启动、停止、等待、唤醒等操作，以及线程安全、锁、同步等概念和技术。 在Java多线程中，线程的创建有两种方式：继承Thread类和实现...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值