Java多线程拾遗 --- 创建线程方式，线程的相关方法，线程锁，线程通信

最新推荐文章于 2022-01-23 18:05:30 发布
最新推荐文章于 2022-01-23 18:05:30 发布
阅读量203 收藏
点赞数
分类专栏： Java学习之路 文章标签： java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_45380083/article/details/122031908
版权

文章目录

回顾一下Java基本的多线程，为JUC打一下基础

1、线程创建

注意：调用run方法和start方法的区别

image-20211219174312196

1.1 继承Thread类

继承Thread类，重写run()方法，编写线程执行体

线程对象使用start()方法启动线程

class MyThread1 extends Thread{

    @Override
    public void run() {
        System.out.println("继承Thread创建==>>"+Thread.currentThread().getName());
    }
}

public class ThreadDemo1 {
    public static void main(String[] args) {
        //1.new一个线程对象  然后执行start方法
        MyThread1 t1 = new MyThread1();
        t1.start();
        //2.或者直接运行
        new MyThread1().start();
    }
}

1.2 实现Runnable接口

一遍推荐实现Runnable接口来创建线程，因为继承有局限性

Thread类本身实现了Runnable接口

和继承Thread类一样，需要重写run()方法，编写线程执行体

线程对象使用start()方法启动线程

注意：要new一个Thread类来代理启动或者用线程池方式等代理启动

class MyThread2 implements Runnable{

    @Override
    public void run() {
        System.out.println("实现Runnable创建==>>"+Thread.currentThread().getName());
    }
}

public class ThreadDemo1 {
    public static void main(String[] args) {
        //实现Runnable的类需要一个 Thread代理类帮助其启动
        Thread t2 = new Thread(new MyThread2());
        t2.start();
        //或者直接运行
        new Thread(new MyThread2()).start();
    }
}

1.3 实现Callable接口

重写call方法，需要抛出异常

使用线程池方式：

先创建一个服务：ExecutorService threadPool = Executors.newFixedThreadPool(1);

再提交执行：Future submit = threadPool.submit(t3);

可以获取call()函数的返回值：submit.get();

最后要关闭服务：threadPool.shutdown();

class MyThread3 implements Callable<String>{

    /*call类型和Callable<?>一致，可自定义*/
    @Override
    public String call() throws Exception {
        String str = "实现Callable创建==>>" + Thread.currentThread().getName();
        System.out.println(str);
        return str;
    }
}

public class ThreadDemo1 {
    public static void main(String[] args) {

        MyThread3 t3 = new MyThread3();
        //实现Callable的类启动方式：FutureTask或线程池等
        FutureTask<String> futureTask = new FutureTask<>(t3);
        new Thread(futureTask).start();

        //创建一个线程池
        ExecutorService threadPool = Executors.newFixedThreadPool(1);
        //submit()参数可以为实现Callable类的
        Future<String> submit = threadPool.submit(t3);
        try {
            String str = submit.get();
            System.out.println(str);
        } catch (InterruptedException | ExecutionException e) {
            e.printStackTrace();
        }

        threadPool.shutdown();
    }
}

2、线程状态和相关方法

2.1 线程五大状态

image-20211219174941216

  1. 线程刚new出来进入新生状态

  2. 调用start()方法进入就绪状态

  3. 就绪状态的线程经过cpu调度进入运行状态

  4. 运行队列满或者调用sleep，wait，被阻塞在临界区外时是阻塞状态

  5. 线程中断或结束进入死亡状态，死亡后不能再次启动

2.2 线程相关方法

2.2.1 优先级setPriority

image-20211219175105427

  • 优先级默认为5，可设置范围为1-10，超出范围会抛出IllegalArgumentException
package com.bandit.ThreadMethod;

public class ThreadDemo2 {
    public static void main(String[] args) {
        MyThread myThread = new MyThread();

        Thread thread1 = new Thread(myThread);
        Thread thread2 = new Thread(myThread);
        Thread thread3 = new Thread(myThread);
        Thread thread4 = new Thread(myThread);
        Thread thread5 = new Thread(myThread);

        thread1.setPriority(6);
        thread2.setPriority(3);
        thread3.setPriority(Thread.NORM_PRIORITY);  //默认5
        thread3.setPriority(Thread.MAX_PRIORITY);   //10
        thread4.setPriority(Thread.MIN_PRIORITY);  //1

        thread1.start();
        thread2.start();
        thread3.start();
        thread4.start();
        thread5.start();

    }
}

class MyThread implements Runnable{

    @Override
    public void run() {
        System.out.println(Thread.currentThread().getName()+"优先级为"+Thread.currentThread().getPriority());
    }
}

实际上运行有很多种结果，这个优先级只是cpu调度该线程的概率

2.2.2 线程休眠sleep

线程执行过程中可以通过sleep进行休眠

注意：sleep不会释放锁

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

public class ThreadSleep {
    public static void main(String[] args) {
        ticketThead ticketThead = new ticketThead();

        new Thread(ticketThead,"小明").start();
        new Thread(ticketThead,"小王").start();
        new Thread(ticketThead,"黄牛").start();
    }
}

class ticketThead implements Runnable{

    //票数
    private int ticketNums = 10;
    @Override
    public void run() {
        while (true) {
            if (ticketNums <= 0) {
                break;
            }
            //捕获异常
            try {
                Thread.sleep(200);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println(Thread.currentThread().getName() + "--->拿到了第" + ticketNums-- + "张票");
        }
    }
}

image-20211219185615031

查看运行，会有拿到0票和负票的，解决方法：加锁

2.2.3 线程停止

不建议使用JDK提供的stop()和destory()方法

推荐设置一个标志位作为终止变量，当flag=false时终止线程运行

public class ThreadStop {
    public static void main(String[] args) {
        stopThread t1 = new stopThread();
        new Thread(t1).start();
		
        try {
            Thread.sleep(1000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        //停止
        t1.stop();
    }
}

class stopThread implements Runnable{
    private boolean flag = true;
    public void stop() {//向外提供一个stop方法设置flag
        this.flag = false;
    }
    @Override
    public void run() {
        while (flag){
            System.out.println("运行");
        }
    }
}

2.2.4 线程礼让yield

让当前正在执行的进程暂停，但不阻塞，即由运行态->就绪态

让cpu重新调度，礼让不一定成功，全靠cpu调度

public class ThreadYield {

    public static void main(String[] args) {
        YieldThread t1 = new YieldThread();
        new Thread(t1,"线程1").start();
        new Thread(t1,"线程2").start();
    }
}

class YieldThread implements Runnable{

    @Override
    public void run() {
        System.out.println(Thread.currentThread().getName() + "线程开始执行");
        Thread.yield();//礼让
        System.out.println(Thread.currentThread().getName() + "线程停止执行");
    }
}

礼让成功：

image-20211219190716583

2.2.5 线程插队join

join可以想象成插队，让其他进程等待此进程执行完后再执行

public class ThreadJoin {
    public static void main(String[] args) {
        JoinThread joinThread = new JoinThread();
        Thread thread = new Thread(joinThread);
        thread.start();

        for (int i = 0; i < 200; i++) {
            if(i==100){//在100时插队
                try {
                    thread.join();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
            System.out.println("主线程"+i);
        }

    }
}

class JoinThread implements Runnable{

    @Override
    public void run() {
        for (int i = 0; i < 200; i++) {
            System.out.println("插队进程"+i);
        }
    }
}

如果不要这段，会先跑完主进程再执行子进程

if(i==100){//在100时插队
    try {
        thread.join();
    } catch (InterruptedException e) {
        e.printStackTrace();
    }
}

2.3 线程状态观测

image-20211219192316286

public class ThreadState {
    public static void main(String[] args) throws InterruptedException {
        Thread thread = new Thread(() -> {
            for (int i = 0; i < 5; i++) {
                try {
                    Thread.sleep(1000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
            System.out.println("//");
        });
        //观察状态
        Thread.State state = thread.getState();
        System.out.println(state);
        //观察启动后
        thread.start();
        state = thread.getState();
        System.out.println(state);//Run
        while (state != Thread.State.TERMINATED) {//只要现成不终止,就一直输出状态
            Thread.sleep(100);
            state = thread.getState();//更新线程状态
            System.out.println(state);
        }
        //死亡后的线程不能再启动了,启动会报异常
        //thread.start();
    }
}

2.4 守护线程

线程分为用户线程和守护线程

  • 用户线程：虚拟机必须保证用户线程执行完毕才关闭
    • main线程和自定义的一些其他Thread线程
  • 守护线程：虚拟机不用等待守护线程执行完毕
    • gc垃圾回收，监控内存，后台记录操作日志等线程

可以通过thread.setDaemon(true)设置线程为守护线程，默认为false

public class ThreadDaemon {
    public static void main(String[] args) {
        God god = new God();
        You you = new You();

        Thread thread = new Thread(god);
        //默认false表示是用户线程,正常的线程都是用户线程...
        thread.setDaemon(true);
        //上帝守护线程启动
        thread.start();
        //你 用户线程启动
        new Thread(you).start();
    }
}
//上帝
class God implements Runnable{
    @Override
    public void run() {
        while (true){
            System.out.println("上帝保佑着你");
        }
    }
}

//你
class You implements Runnable{
    @Override
    public void run() {
        for (int i = 0; i < 36500; i++) {
            System.out.println("你一生都开心的活着");
        }
        System.out.println("====goodbye!world====");
    }
}

3、线程锁

多个线程访问一个临界资源时需要加锁，让访问的线程排列成队列互斥访问临界区

3.1 synchronized

当一个线程获得对象的排他锁，独占资源，其他线程必须等待该进程使用资源后释放锁才能访问

存在问题：

  • 一个线程持有锁会导致其他需要此锁的线程挂起
  • 多线程竞争时加锁解锁频繁会引起性能问题
  • 如果一个优先级低的线程拿到了锁，让优先级高的等待会导致优先级倒置现象

3.1.1 方法锁

缺陷：如果将一个大方法直接申明为synchronized会影响效率

改造之前买票的案例

public class SynchronizedDemo {
    public static void main(String[] args) {
        ticketThead ticketThead = new ticketThead();

        new Thread(ticketThead,"小明").start();
        new Thread(ticketThead,"小王").start();
        new Thread(ticketThead,"黄牛").start();
    }

}

class ticketThead implements Runnable{

    //票数
    private int ticketNums = 10;
    @Override
    public synchronized void run() {
        while (true) {
            if (ticketNums <= 0) {
                break;
            }
            //捕获异常
            try {
                Thread.sleep(200);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println(Thread.currentThread().getName() + "--->拿到了第" + ticketNums-- + "张票");
        }
    }
}

此处临界区为run方法，所以在run方法上加锁

3.1.2 块锁

  • synchronized ( Obj ) { }
  • Obj 称为 同步监视器，就是上锁的对象
public class SynchronizedDemo {
    public static void main(String[] args) {
        List<String> list = new ArrayList<String>();
        for (int i = 0; i < 1000; i++) {
            new Thread(()->{
                synchronized (list){//给list上锁
                    list.add(Thread.currentThread().getName());
                }
            }).start();
        }
        System.out.println(list.size());
    }
}

3.2 Lock

  • 从JDK5.0开始，java提供了一个更强大的同步锁Lock

  • 每次只能有一个线程对Lock对象加锁，线程开始访问共享资源之前应该先获得Lock对象

  • ReentrantLock类实现了Lock，拥有与synchronized相同的并发性和内存语义，可以显示加锁解锁

购票问题的Lock实现

public class LockDemo {
    public static void main(String[] args) {
        ticketThead ticketThead = new ticketThead();

        new Thread(ticketThead,"小明").start();
        new Thread(ticketThead,"小王").start();
        new Thread(ticketThead,"黄牛").start();
    }
}


class ticketThead implements Runnable{

    //票数
    private int ticketNums = 10;
    private ReentrantLock lock = new ReentrantLock();
    @Override
    public void run() {
        while (true) {
            try {
                lock.lock();//加锁
                //买票
                if (ticketNums <= 0) {
                    break;
                }
                try {
                    Thread.sleep(200);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            } catch (Exception e) {
                e.printStackTrace();
            }finally {
                lock.unlock();//解锁
            }
            System.out.println(Thread.currentThread().getName() + "--->拿到了第" + ticketNums-- + "张票");
        }
    }
}

3.3 synchronized 和 lock 对比

image-20210216110142335

4、线程通信

4.1 引入

操作系统中生产者消费者问题：采用信号量法

对信号量有Wait和Signal操作，

同样的，在Java中也有类似的操作：

  • wait()：线程一直等待直到其他线程通知，与sleep不同，会释放锁
  • wait(Long timeout)：指定等待时间
  • notify()：唤醒一个等待状态的线程
  • notfiyAll()：唤醒同一个对象上所以调用wait()方法的线程，优先级高的线程先唤醒

注意：以上方法只能在同步方法或同步块中使用，否则会抛出异常

4.2 生产者消费者问题

4.2.1 缓冲区法

//缓冲区法
public class Demo01 {
    public static void main(String[] args) {
        SynContainer synContainer = new SynContainer();
        new Producer(synContainer).start();
        new Consumer(synContainer).start();
    }
}



//生产者
class Producer extends Thread {
    //容缓冲区
    SynContainer container;

    public Producer(SynContainer container) {
        this.container = container;
    }

    //生产
    @Override
    public void run() {
        for (int i = 0; i < 100; i++) {
            container.push(new Product(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 Product {
    int id;//产品编号

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

//缓冲区
class SynContainer {
    //需要一个容器大小
    Product[] products = new Product[10];
    //容器计数器
    int count = 0;

    //生产者放入产品
    public synchronized void push(Product product) {
        //如果容器满了,需要等待消费者消费
        /*如果是if的话，假如消费者1消费了最后一个，这是index变成0此时释放锁被消费者2拿到而不是生产者拿到，这时消费者的wait是在if里所以它就直接去消费index-1下标越界，如果是while就会再去判断一下index得值是不是变成0了*/
        while (count == products.length) {
            //通知消费者消费,等待生产
            try {
                this.wait();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
        //如果没有满,需要丢入产品
        products[count] = product;
        count++;
        //通知消费者消费
        this.notifyAll();
    }

    //消费者消费产品
    public synchronized Product pop() {
        //判断是否能消费
        while (count <= 0) {
            //等待生产者生产
            try {
                this.wait();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
        //如果可以消费
        count--;
        Product product = products[count];
        //吃完了 通知生产者生产
        this.notifyAll();
        return product;
    }
}

4.2.2 标志位法

//产品-->节目
public 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.voice = voice;
       this.notifyAll();
       this.flag = !flag;

   }

   //观看
   public synchronized void watch(){
       if(flag){
           try {
               this.wait();
           } catch (InterruptedException e) {
               e.printStackTrace();
           }
       }
       System.out.println("观众观看了" + voice);
       //通知演员表演
       this.notifyAll();
       this.flag = !flag;
   }
}

public class Player extends Thread {
   private TV tv = null;

   public Player(TV tv) {
       this.tv = tv;
   }

   @Override
   public void run() {
       for (int i = 0; i < 100; i++) {
           tv.play("表演了" + i + "号节目");
       }
   }
}

public class Watcher extends Thread {

   private TV tv = null;

   public Watcher(TV tv) {
       this.tv = tv;
   }

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

//测试生产者消费者问题:信号灯法,标志位解决
public class Main {

   public static void main(String[] args) {
       TV tv = new TV();
       new Watcher(tv).start();
       new Player(tv).start();

   }
}

5、线程池

5.1 介绍

背景: 经常创建和销毁,使用量特别大的资源,比如并发情况下的线程,对性能影响很大
思路: 提前创建好多个线程,放入线程池中,使用时直接获取,使用完毕放回池中,可以避免频繁的创建销毁,实现重复利用,类似生活中的工共交通工具
好处：

  • 提高了响应速度(减少了创建新线程的时间)
  • 降低资源消耗(重复利用线程池中线程,不需要每次都创建)
  • 便于线程管理(…)
  • corePoolSize: 核心池的大小
  • maximumPoolSize: 最大线程数
  • keepAliveTime: 线程没有任务时最多保持多长时间后会终止

5.2 使用线程池

先创建一个线程池：ExecutorService threadPool = Executors.newFixedThreadPool(1);

再提交执行：

  • Future submit = threadPool.submit(t3); 括号里为Callable接口方法
  • threadPool.invokeAll(callables); 括号里为Callable接口方法的集合
  • threadPool.execute(new MyThread()); 括号里为Runnable接口方法

可以获取call()函数的返回值：submit.get();

最后要关闭服务：threadPool.shutdown();

public class Demo02 {

    public static void main(String[] args) {

        ExecutorService threadPool = Executors.newFixedThreadPool(3);
        //callable
        Future<String> submit = threadPool.submit(new MyThread());
        //runnable
        threadPool.execute(new MyThread2());
        //callable List任务集合
        ArrayList<Callable<String>> callables = new ArrayList<>();
        callables.add(new MyThread());
        callables.add(new MyThread());
        try {
            threadPool.invokeAll(callables);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        
        
        threadPool.shutdown();
    }

}

class MyThread implements Callable<String> {

    @Override
    public String call() throws Exception {
        String str = "实现Callable创建==>>" + Thread.currentThread().getName();
        System.out.println(str);
        return str;
    }
}

class MyThread2 implements Runnable{

    @Override
    public void run() {
        System.out.println("实现Runnable创建==>>"+Thread.currentThread().getName());
    }
}
化身强盗_Bandit
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
【Java多线程编程核心技术】7.拾遗增补-笔记总结
DChuan
11-23 507
相关链接： 【Java多线程编程核心技术】1.Java多线程技能-笔记总结 【Java多线程编程核心技术】2.对象及变量的并发访问（上）-笔记总结 【Java多线程编程核心技术】2.对象及变量的并发访问（下）-笔记总结 【Java多线程编程核心技术】3.线程间通信 -笔记总结 【Java多线程编程核心技术】4.Lock的使用-笔记总结 【Java多线程编程核心技术】5.定时器Timer...
java基础性代码拾遗-4（多线程）
beeworkshop的博客
03-22 108
1. 进程和线程的区别 区别 进程 线程 根本区别 作为资源分配的单位 调度执行的单位 开销 每个进程都有独立的代码和数据空间（进程上下文），进程间的切换会有较大的开销。切换发生在不同的内存地址上。 轻量级进程，同一类线程共享代码和数据空间，每个线程有独立的运行栈，以及程序计数器。线程的切换开销小。切换发生在同一内存地址上。 内存分配 每个进程分配不同的内存区域。 不会为线...
java多线程拾遗(一) 创建线程的三种方式
阳光大男孩！！！的博客
03-18 235
前言 java创建线程的三种方式分别是继承Thread类、 实现Runnable接口、 实现Callable接口。 继承Thread 这种方式是通过新建继承于Thread的类，并重写run()方法来实现的,run()方法主要是指定你要让这个线程为你做什么 public static void main(String[] args) { Thread add...
Java拾遗-------多线程
u012935756的专栏
08-31 418
一.os中进程和线程的区别现在的os都是多任务操作系统，多线程是实现多任务的一种方式。 进程是指一个内存中运行的应用程序，每个进程都有自己独立的一块内存空间，一个进程中可以启动多个线程。比如在Windows系统中，一个运行的exe就是一个进程。线程是指进程中的一个执行流程，一个进程中可以运行多个线程。比如java.exe进程中可以运行很多线程。线程总是属于某个进程，进程中的多个线程共享进程的内存。
【Java多线程编程核心技术】3.线程间通信 -笔记总结
DChuan
11-19 571
相关链接： 【Java多线程编程核心技术】1.Java多线程技能-笔记总结 【Java多线程编程核心技术】2.对象及变量的并发访问（上）-笔记总结 【Java多线程编程核心技术】2.对象及变量的并发访问（下）-笔记总结 【Java多线程编程核心技术】3.线程间通信 -笔记总结 【Java多线程编程核心技术】4.Lock的使用-笔记总结 【Java多线程编程核心技术】5.定时器Timer...
【Java多线程编程核心技术】1.Java多线程技能-笔记总结
DChuan
11-13 1453
相关链接： 【java多线程编程核心技术】1.java多线程技能-笔记总结 【java多线程编程核心技术】2.对象及变量的并发访问（上）-笔记总结 【java多线程编程核心技术】2.对象及变量的并发访问（下）-笔记总结 【java多线程编程核心技术】3.线程间通信 -笔记总结 【java多线程编程核心技术】4.Lock的使用-笔记总结 【java多线程编程核心技术】5.定时器Timer
Java多线程拾遗(四) 使用ReentrantLock和synchronized来保证线程安全
阳光大男孩！！！的博客
03-18 780
前言 在多个线程，同时对共享资源进行操作时，会因为线程不安全，造成数据错误。在java中有不同的锁机制来避免这一问题，除此之外，还有一些线程安全的集合也供我们使用。 可能我们耳熟能详的是某些集合是线程安全的，某些是线程不安全的。线程安全的集合保证线程安全的方法也不是都一样的。 今天我们看看如何使用可重入锁ReentrantLock和synchronized来保证线程安全。 线程不安全的情况 在j...
Java多线程拾遗(九) Volitate关键字特性分析
阳光大男孩！！！的博客
06-25 6216
前言 编译器为了加快程序运行的速度,对一些变量的写操作会先在寄存器或者是CPU缓存上进行,最后才写入内存.而在这个过程,变量的新值对其他线程是不可见的.而volitate的作用就是使它修饰的变量的读写操作都必须在内存中进行。 这样就保证了volitate修改的变量具有可见性，也就是某个线程更改了这个变量，其他线程再去读主内存，想要修改这个值时，前一个线程的修改对当前线程是可见的。 volatile关键字的两层语义 一旦一个共享变量（类的成员变量、类的静态成员变量）被volatile修饰之后，那么就具备了两层
Java多线程编程核心技术（笔记）7-拾遗补增
qq_38171871的博客
08-25 93
拾遗补增7.1 线程的状态7.1.1 验证new、runnable、terminated7.1.2 验证time_waiting7.1.3 验证blocked7.1.4 验证waiting7.2 线程组 7.1 线程的状态 7.1.1 验证new、runnable、terminated 首先验证的是 NEW、RUNNABLE 及 TERMINATED 状态，NEW 状态是线程实例化后还从未执行 start() 方法时的状态，而 RUNNABLE 状态是线程进入运行的状态，TERMINATED 是线程被销毁
61.拾遗增补-线程的状态.mp4
04-06
在学习Java过程中，自己收集了很多的Java的学习资料，分享给大家，有需要的欢迎下载，希望对大家有用，一起学习，一起进步。
63.拾遗增补-线程的状态-Callable接口.mp4
04-06
在学习Java过程中，自己收集了很多的Java的学习资料，分享给大家，有需要的欢迎下载，希望对大家有用，一起学习，一起进步。
62.拾遗增补-线程的状态-通过代码验证.mp4
04-06
在学习Java过程中，自己收集了很多的Java的学习资料，分享给大家，有需要的欢迎下载，希望对大家有用，一起学习，一起进步。
java面试进阶讲义
01-22
- **线程概述**：这部分介绍了 Java 多线程的基本概念，包括线程的生命周期、创建方式等。 - **同步机制**：例如 `synchronized` 关键字和 `ReentrantLock` 类，用于保证线程安全。 - **线程池**：使用 `...
五种提高 SQL 性能的方法
12-15
另外，也可以通过创建一个FOR INSERT触发器来自动返回IDENTITY值，这在多线程或分布式系统中更为可靠。 2. **内嵌视图与临时表** 内嵌视图和临时表在处理复杂查询时能够提供帮助。内嵌视图可以在查询中创建临时的...
SpringMVC---使用注解开发，404错误原因，RESTful，页面跳转，Json交互
化身强盗的博客
08-23 2279
四.SpringMVC项目搭建（注解版） 1.首先配置springmvc-servlet.xml <?xml version="1.0" encoding="UTF-8"?> <beans xmlns="http://www.springframework.org/schema/beans" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:context="http://www.spring
JavaWeb---IDEA的Tomcat与Maven环境搭建
化身强盗的博客
08-02 1593
1.Tomcat配置 (1)进入Tomcat官网下载Tomcat9，不用10是因为tomcat10把 javax.servlet 都改为了jakarta.servlet，后面Maven导servlet相关依赖会用不了 (2)Tomcat解压就能使用，但是需要配置环境变量JAVA_HOME和Tomcat的环境变量 JAVA_HOME选择jdk所在位置 CATALINA_BASE选择tomcat根目录 CATALINA_HOME选择tomcat根目录 然后再Path中新增如上三条 2.Maven环境配
Netty入门（一） --- Reactor线程模型，Netty的线程模型，快速入门Demo
化身强盗的博客
01-21 1002
文章目录一、Netty概述1.1 简介1.2 原生NIO的问题1.3 Netty的优点二、线程模型2.1 传统阻塞IO服务模型特点：问题：2.2 Reactor模式2.2.1 单Reactor单线程流程说明：优缺点分析：2.2.2 单Reactor多线程流程说明：优缺点：2.2.3 主从Reactor多线程流程说明：优缺点：总结三、Netty模型原理描述：快速入门demo 一、Netty概述 1.1 简介 官网：https://netty.io/ Netty是一个NIO客户端服务器框架，它可以快速简单地开发
Netty入门（二）--- 任务队列，异步模型剖析，Http服务Demo
化身强盗的博客
01-23 948
文章目录四、Netty异步操作4.1 taskQueue任务队列4.2 scheduleTaskQueue定时任务4.3 非当前Reactor调用Channel的方法4.4 Netty异步模型原理剖析4.4.1 ChannelFuture4.4.2 Future-Listener 机制4.5 Http服务Demo 往期 Netty入门（一） — Reactor线程模型，Netty的线程模型，快速入门Demo 四、Netty异步操作 Netty任务队列的 Task 有3中使用场景 用户程序自定义的普通任
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值