Java线程下篇

已于 2023-06-26 10:39:59 修改
阅读量327 收藏
点赞数 1
分类专栏： javaSE-学习笔记 文章标签： 学习 java jvm
于 2023-03-05 20:04:42 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/a778203081/article/details/129350220
版权

学习任务

零、 复习昨日
一、作业
二、进程与线程
三、创建线程
四、线程的API
五、线程状态
六、线程同步

二、进程与线程[了解]

一个进程就是一个应用程序,进程包含线程
一个进程至少包含一个线程,大部分都是有多条线程在执行任务(多线程)

进程是系统资源分配的最小单位

线程是进程内部的一个执行任务

进程内多个线程是共享进程资源,线程是资源调度的最小单位

Java程序是否是多线程的吗?
答: 是! 至少有main线程,垃圾回收线程等等

三、创建线程[重点]

Thread

创建线程的方式有很多

  • 继承Thread
  • 实现Runnable接口
  • 使用Callable 和Future来完成
  • 使用线程池获得线程
  • 其实底层都是Runnable接口

3.1 继承Thread

步骤

  1. 自定义类
  2. 继承Thread
  3. 重写run方法
  4. 创建子类对象
  5. 调用start方法启动线程 [特别强调,开启新线程的方法是start]
    start方法内部执行时会调用run方法执行
public class MyThread extends Thread{

    // 重写方法,方法内部,就是该线程执行的任务
    @Override
    public void run() {
        for (int i = 1; i < 11; i++) {
            System.out.println("MyThread --> "+i );
        }
    }
}

    public static void main(String[] args) {

        // 创建一个线程
        MyThread myThread = new MyThread( );
        // 启动线程
        myThread.start();

        // ==============main线程执行====================
        for (int i = 1; i < 11; i++) {
            System.out.println("main-Thread" + i );
        }
        
        // 自定义线程和主线程同时执行,并且出现资源争抢情况
    }

使用匿名内部类的形式开启线程

        // ==========匿名内部类的方法开启线程==============
        new Thread(){
            @Override
            public void run() {
                for (int i = 1; i < 1001; i++) {
                    System.out.println("my-Thread-2 --> " + i );
                }
            }
        }.start();

myThread线程,main线程,my-Threah-2线程3个在争抢资源,如果没有出现效果,把主线程执行的代码放在最下方,因为主线程代码优先级较高,会优先执行…

3.2 实现Runnable接口

步骤

  1. 自定义类
  2. 实现Runnable接口
  3. 重写run方法
  4. 创建子实现类对象
  5. 把子实现类对象当构造方法的方法参数来创建Thread对象
  6. 由thread调用start方法开启线程
public class MyRunnable implements Runnable{
    @Override
    public void run() {
        for (int i = 1; i < 101; i++) {
            System.out.println("MyRunnable - 1 --> " + i);
        }
    }
}

    public static void main(String[] args) {
        // 4 创建实现类对象
        MyRunnable myRunnable = new MyRunnable( );

        // 5 把对象当构造方法参数,创建Thread对象
        Thread thread = new Thread(myRunnable);
        // 6 开启线程
        thread.start();
    }

匿名内部类的形式创建线程

// ============= 匿名内部类完成实现Runnable接口 ============
new Thread(new Runnable(){
    @Override
    public void run() {
        for (int i = 1; i < 101; i++) {
            System.out.println("MyRunable-2 --> " + i );
        }
    }
} ).start();

3.3 区别

继承Thread开启线程和实现Runnable接口开启线程有什么区别?

  • 一个继承,一个实现
  • 继承Thread后,直接创建对象即可调用start开启线程
  • 实现Runnable接口的子类,还需要再创建Thread类对象才可以调用strat开启线程

从使用便捷度来说,继承Thread开启线程会方便一点…

继承Thread类就限制了该类再继承别的类,因为类只能单继承,而实现接口的同时可以继承别的类,并且还允许多继承.

所以推荐使用接口来实现.

四、线程的API[熟悉]

  • void start() 开启线程,会自动run方法执行线程任务
  • void run() 执行线程的方法
    • run() 方法是start开启线程后,JVM自动调用
  • void setName(String name) 给线程设置名字
    • 也可以通过构造方法,在创建线程时指定线程名
  • String getName() 获得线程的名字
  • static Thread currentThread() 返回当前正在执行的线程对象
  • setPriority(int priority) 设置优先级
    • 级别是1-10 ,默认是5
  • getPriority() 获得优先级
  • join() 加入线程,等待该线程终止
  • join(int milles) 加入线程,最大等待直到毫秒数
  • void setDaemon(boolean on) 设置守护线程
  • static void yield() 礼让线程,暂停当前线程,让其他线程执行
  • static void sleep(long milles) 线程休眠
    • 会让当前线程暂停执行,让出系统资源,让其他线程执行
    • 时间到,当前会继续和其他争抢资源执行
  • void stop() 结束当前线程,线程死亡(已过式)
    • 被废弃的原因是因为这个中断线程太直接太暴力…
package com.qf.thread;

/**
 * --- 天道酬勤 ---
 *
 * @author QiuShiju
 * @desc 演示线程API
 */
public class TestThread3 {

    public static void main(String[] args) {
        testStop();
    }

    /**
     * 测试线程停止
     */
    public static void testStop() {
        Thread thread = new Thread("好人") {
            @Override
            public void run() {
                for (int i = 0; i < 10000; i++) {
                    if (i == 5000) {
                        Thread.currentThread().stop();
                    }
                    System.out.println(Thread.currentThread( ).getName( ) + " ---> " + i);
                }
            }
        };


        thread.start( );
    }


    public static void testSleep2() {
        Thread thread2 = new Thread("人") {
            @Override
            public void run() {
                for (int i = 0; i < 10000; i++) {
                    System.out.println(Thread.currentThread( ).getName( ) + " --->" + i);
                }
            }
        };

        Thread thread = new Thread("好人") {
            @Override
            public void run() {
                for (int i = 0; i < 10000; i++) {
                    if (i == 500) {
                        try {
                            Thread.sleep(10);
                        } catch (InterruptedException e) {
                            e.printStackTrace( );
                        }
                    }
                    System.out.println(Thread.currentThread( ).getName( ) + " ---> " + i);
                }
            }
        };


        thread.start( );
        thread2.start( );
    }


    /**
     * 演示线程休眠
     */
    public static void testSleep() {
        System.out.println("倒计时.." );
        for (int i = 5; i > 0; i--) {
            System.out.println(i );
            // 线程休眠1秒钟
            try {
                // 让当前主线程睡觉
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace( );
            }
        }
        System.out.println("发射!" );
    }


    /**
     * 演示加入线程
     */
    public static void testJoin() {
        Thread thread2 = new Thread("人") {
            @Override
            public void run() {
                for (int i = 0; i < 10000; i++) {
                    System.out.println(Thread.currentThread( ).getName( ) + " --->" + i);
                }
            }
        };

        Thread thread = new Thread("好人") {
            @Override
            public void run() {
                for (int i = 0; i < 10000; i++) {
                    if (i == 500) {
                        try {
                            // 线程1(好人)执行到500,让线程2(人)加入执行,直到该线程结束,当前线程再继续执行
                            //thread2.join();

                            // 线程1(好人)执行到500,让线程2(人)加入执行,让其运行指定毫秒时间
                            // 时间到,线程再争抢资源
                            thread2.join(10);
                        } catch (InterruptedException e) {
                            e.printStackTrace( );
                        }
                    }
                    System.out.println(Thread.currentThread( ).getName( ) + " ---> " + i);
                }
            }
        };


        thread.start( );
        thread2.start( );
    }

    /**
     * 演示礼让线程
     */
    public static void testYield() {
        Thread thread = new Thread("好人") {
            @Override
            public void run() {
                for (int i = 0; i < 10000; i++) {
                    // 获得当前正在执行线程对象
                    if (i == 500) {
                        Thread.yield( );
                    }
                    System.out.println(Thread.currentThread( ).getName( ) + " ---> " + i);
                }
            }
        };

        Thread thread2 = new Thread("人") {
            @Override
            public void run() {
                for (int i = 0; i < 10000; i++) {
                    System.out.println(Thread.currentThread( ).getName( ) + " --->" + i);
                }
            }
        };

        thread.start( );
        thread2.start( );
    }


    /**
     * 演示守护线程
     */
    public static void testDaemon() {
        Thread thread = new Thread("皇上") {
            @Override
            public void run() {
                for (int i = 0; i < 1; i++) {
                    // 获得当前正在执行线程对象
                    System.out.println(Thread.currentThread( ).getName( ) + " ---> " + i);
                }
            }
        };

        Thread thread2 = new Thread("妃子") {
            @Override
            public void run() {
                for (int i = 0; i < 10000; i++) {
                    System.out.println(Thread.currentThread( ).getName( ) + " --->" + i);
                }
            }
        };

        // 开启前设置某个线程为守护线程
        thread2.setDaemon(true);
        // 一旦设置一个线程为守护线程,那么其他的线程就是被守护的


        thread.start( );
        thread2.start( );
    }


    /**
     * 演示关于线程优先级的方法
     */
    public static void testPriority() {
        Thread thread = new Thread("和谐号1") {
            @Override
            public void run() {
                for (int i = 0; i < 10000; i++) {
                    // 获得当前正在执行线程对象
                    System.out.println(Thread.currentThread( ).getName( ) + " ---> " + i);
                }
            }
        };

        Thread thread2 = new Thread("复兴号2") {
            @Override
            public void run() {
                for (int i = 0; i < 10000; i++) {
                    System.out.println(Thread.currentThread( ).getName( ) + " --->" + i);
                }
            }
        };

        // 默认优先级是5,
        System.out.println(thread.getName( ) + "--->" + thread.getPriority( ));
        System.out.println(thread2.getName( ) + "--->" + thread2.getPriority( ));

        // 设置优先级,最高是10,最低是1,不能越界
        // 注意不是一定优先级高的先执行,只是大概率上会是
        thread.setPriority(1);
        thread2.setPriority(10);

        thread.start( );
        thread2.start( );
    }

    /**
     * 演示关于线程名字的方法
     */
    public static void testName() {
        // 通过构造方法设置线程名
        Thread thread = new Thread("和谐号") {
            @Override
            public void run() {
                for (int i = 0; i < 10; i++) {
                    // 获得当前正在执行线程对象
                    System.out.println(Thread.currentThread( ).getName( ) + " ---> " + i);
                }
            }
        };

        Thread thread2 = new Thread( ) {
            @Override
            public void run() {
                for (int i = 0; i < 10; i++) {
                    System.out.println(Thread.currentThread( ).getName( ) + " --->" + i);
                }
            }
        };
        // 获得线程名
        // 默认线程名,从Thread-0开始
        //System.out.println(thread.getName( ));

        // 通过setName设置线程名
        thread2.setName("绿皮");

        //System.out.println(thread2.getName( ));

        thread.start( );
        thread2.start( );

        // 获得主线程的名字
        System.out.println(Thread.currentThread( ).getName( ));
    }
}

五、线程状态[面试]

线程的几种状态:

  • 创建/新建/初始
    • new 完线程对象
  • 就绪
    • 调用start
  • 等待/阻塞
    • join()或者sleep()
  • 运行
    • 执行run()方法
  • 死亡/销毁/终止
    • run方法执行完,或者调用stop()或者interrupt()中断等

清楚状态之间的转换

image-20230302170320045

六、线程安全[重点]

6.1 线程安全

  • 临界资源：共享资源(同⼀个对象)，一次只可以有一个线程操作，才可以保证准确性

  • 原子操作：不可拆分的步骤，被视作一个整体。其步骤不能打乱

线程不安全: 1) 完整的步骤可能会被破坏 2) 线程内的数据可能被别的线程修改

6.2 线程安全方式

  • 同步方法
    • 给方法加锁,即设置同步锁关键词synchronized
    • 锁对象是当前对象,即this
  • 同步代码块
    • 将需要安全的代码使用同步代码块包裹,设置锁对象.
    • 锁可以是任意对象
    • 但是线程之前应该是同一把锁才能锁住,保证安全

其实就是给需要"同步",需要"安全",需要"步骤一致,不能打乱"的代码加锁.

需求: 要求打印机类的两个方法分别被两个线程同时执行.但是方法执行时不能被破坏,即方法执行时不能被另外一个线程抢走资源,要保证方法执行时步骤完整性.

package com.qf.sync;

import java.util.Date;

/**
 * --- 天道酬勤 ---
 *
 * @author QiuShiju
 * @desc 打印机
 */
public class Printer {

    // 锁需要是同一对象
    private Object obj = new Object();

    // 打印机1号
    public synchronized void print1() {
       //synchronized (obj){
            System.out.print(1+" ");
            System.out.print(2+" ");
            System.out.print(3+" ");
            System.out.print(4+" ");
            System.out.print("\r\n");
        //}
    }


    // 打印机2号
    public synchronized void print2() {
        //synchronized (obj) {
            System.out.print("一 ");
            System.out.print("二 ");
            System.out.print("三 ");
            System.out.print("四 ");
            System.out.print("\r\n");
        //}
    }
}

    public static void main(String[] args) {
        Printer printer = new Printer( );

        // 线程1
        new Thread(){
            @Override
            public void run() {
                while(true){
                    printer.print1();
                }
            }
        }.start();

        // 线程2
        new Thread(){
            @Override
            public void run() {
                while(true){
                    printer.print2();
                }
            }
        }.start();
    }
}

换种方式写

public class TestSync2 {
	public static void main(String[] args) {
        // 线程1
        new Thread( ) {
            @Override
            public void run() {
                for (; ; ) {
                    synchronized (TestSync2.class) {
                        System.out.print(1 + " ");
                        System.out.print(2 + " ");
                        System.out.print(3 + " ");
                        System.out.print(4 + " ");
                        System.out.print("\r\n");
                    }
                }
            }
        }.start( );

        // 线程2
        new Thread( ) {
            @Override
            public void run() {
                for (; ; ) {
                    synchronized (TestSync2.class) {
                        System.out.print("一 ");
                        System.out.print("二 ");
                        System.out.print("三 ");
                        System.out.print("四 ");
                        System.out.print("\r\n");
                    }
                }
            }
        }.start( );
    }
}

6.3 转账案例

需求: 假设银行账户类,属性有卡号,余额,名字 ; 另外有ATM机器,机器内能接收账户,给ATM指定取的钱数.ATM支持多线程操作.

// 账户
public class Account {

    private String id;
    private double balance;

    public Account() {
    }

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

    public String getId() {
        return id;
    }

    public void setId(String id) {
        this.id = id;
    }

    public double getBalance() {
        return balance;
    }

    public void setBalance(double balance) {
        this.balance = balance;
    }
}

public class ATM extends Thread {

    private Account account;
    private double money;
    // 取钱是多线程操作
    @Override
    public void run() {
        synchronized (ATM.class){
            if (account.getBalance() >= money) {
                // 模拟出钱的时间,目的是让出资源,让另外的线程执行,模拟争抢
                // 加锁后,sleep"抱着锁睡觉",是说线程休眠不会让出锁,即不会让出资源,其他线程无法执行,
                // 等着这个线程休眠结束并且执行完毕
                try {
                    Thread.sleep(5000);
                } catch (InterruptedException e) {
                    e.printStackTrace( );
                }
                account.setBalance(account.getBalance() - money);
                System.out.println(Thread.currentThread().getName() + "取钱成功,取出" +money );
                System.out.println("余额:" + account.getBalance() );

            } else {
                System.out.println("你有多少钱,心里没数?!" );
            }
        }
    }

    public ATM() {
    }

    public ATM(Account account, double money,String name) {
        super(name);
        this.account = account;
        this.money = money;
    }

    public Account getAccount() {
        return account;
    }

    public void setAccount(Account account) {
        this.account = account;
    }

    public double getMoney() {
        return money;
    }

    public void setMoney(double money) {
        this.money = money;
    }
}

public class Bank {

    public static void main(String[] args) {
        Account account = new Account("888888", 1000);
        new ATM(account,600,"小红").start();
        new ATM(account,600,"小黑").start();
    }
}

变式: 转账案例使用Runable接口来实现

练习

售票: 有一个窗口类售票,总共100张票,窗口不止一个可以多个窗口同时售票. 要保证票不能卖超,不能卖重复的票

6.4 线程安全的方式

不只有synchronized同步方法可以保证线程安全,其实还有很多

ThreadLocal

Volatile

Lock

ReentrantLock

等

二手Java程序员
关注
  • 1
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
java多线程并发
weixin_48288539的博客
10-27 2645
介绍java线程并发机制
【Java篇】多线程详解
Kingharbor的博客
07-05 4847
二、线程安全 1. 线程安全问题引入 对于一个变量的操作： 使用 赋值 读取 写入 加载 上锁 解锁 多个线程同时操作同一个变量：就会因为内存中原子操作不及时等原因导致重复(非同步操作)操作 2.解决线程安全问题 保证对于这个共享资源的操作必须是原子操作 对资源加锁，操作完成之后释放锁 synchronized 关键字 隐式锁 加锁与解锁 不可代码操作的 Lock接口下的锁 显式锁 主动的加锁 与 解锁 lock unlock 在锁块中的代码如果出现了异常中断，卡住 导致此资
万字图解Java多线程
qq_35598736的博客
09-06 6万+
前言 java多线程我个人觉得是javaSe中最难的一部分，我以前也是感觉学会了，但是真正有多线程的需求却不知道怎么下手，实际上还是对多线程这块知识了解不深刻，不知道多线程api的应用场景，不知道多线程的运行流程等等，本篇文章将使用实例+图解+源码的方式来解析java多线程。 文章篇幅较长，大家也可以有选择的看具体章节，建议多线程的代码全部手敲，永远不要相信你看到的结论，自己编码后运行出来的，才是自己的。 什么是java多线程? 进程与线程 进程 当一个程序被运行，就开启了一个进程， 比如启动了qq，w.
Java线程系列详解
wang_yong_hui_1234的博客
04-15 4101
1）volatile本质是在告诉jvm当前变量在寄存器中的值是不确定的，需要从主存中读取，synchronized则是锁定当前变量，只有当前线程可以访问该变量，其他线程被阻塞住。2）volatile仅能使用在变量级别，synchronized则可以使用在变量，方法。3）volatile仅能实现变量的修改可见性，而synchronized则可以保证变量的修改可见性和原子性。4）volatile不会造成线程的阻塞，而synchronized可能会造成线程的阻塞。
Java21虚拟线程实践
xindoo
09-24 7285
虚拟线程是一种轻量化的线程封装，由jvm直接调度和管理。反之普通的线程其实是调用的操作系统的能力，对应的是操作系统级的线程。相对虚拟线程来说操作系统级的线程持有成本很高，而且受操作系统调度和管理的。实际在普通多线程情况下，如果出现IO阻塞，这个线程就必须得跟着阻塞，这个线程对应的操作系统就被阻塞，而他却持有大量的内存。另外，要处理大量的IO就得新建更多线程，而大量的线程会在操作系统切换时因上下文切换导致大量的CPU被浪费。
编程必备：JAVA多线程详解
拾一二的博客
06-14 7996
多线程已经成为一种常见的编程模式，广泛应用于各种不同类型的应用程序中。本篇博客文章中，我们将会探讨多线程编程的相关知识和技巧。通过代码示例和实际应用案例来深入了解多线程的具体实现和应用方法，帮助更好地掌握多线程编程技术，提高程序效率和性能。后期随学习深入还会补充修改。以上就是我对多线程的个人简介，后续会不断完善更新，与大家共勉。
java多线程编程实例
延陵缥缈的博客
05-25 8万+
        这篇文章主要介绍了java多线程编程实例，分享了几则多线程的实例代码，具有一定参考价值，加深多线程编程的理解还是很有帮助的，需要的朋友可以参考下。1.相关知识：Java多线程程序设计到的知识：（1）对同一个数量进行操作（2）对同一个对象进行操作（3）回调方法使用（4）线程同步，死锁问题（5）线程通信等等2．示例2.1三个售票窗口同时出售20张票程序分析：    (1)票数要使用同一...
Java多线程实战-从零手搓一个简易线程池(一)定义任务等待队列
热门推荐
qq_35716689的博客
03-25 19万+
开个新坑-手搓简易线程池。本系列文章将从零开始,一步步手工编码实现一个简单但功能完备的线程池。我们将逐步介绍线程池的各个核心组件,并分析它们的作用和实现思路。通过这个过程,我们可以更好地掌握多线程编程的技巧,并培养编码能力和系统性思维。
JAVA进程和线程
程序猿追的博客
11-06 8904
进程就是正在运行的程序，它是系统资源调度的独立单位，并且一个进程可以执行多个任务，而线程就是程序执行的任务，它是程序使用CPU的基本单位，因此也可以说线程是依赖于进程的。像比如任务管理器里面的运行任务就是线程。
Java线程VS操作系统线程
子牙老师
11-12 2500
hello，小伙伴们好，我是江湖人送外号[道格牙]的子牙老师。 今天给大家分享的文章聚焦讲清楚Java线程与操作系统线程之间的关系。我会通过讲清楚这几个问题来让你对这个关系有一个全面的认识，让你在面试中能够让面试官眼前一亮：嚓，这就是我要找的人啊，太特么靠谱了！帮我“背锅”刚刚好。毕竟我的锅太重，一个人背不动。 大概五个问题： Java线程创建的完整流程 Java的线程是何时与JVM线程绑定的 JVM线程是何时与OS线程绑定的 Java线程对应的OS线程有什么特殊的地方 调用JavaAPI为什么能够操作O
java多线程_java多线程下变量共享_
09-30
本篇文章将深入探讨Java多线程下变量共享的问题以及解决策略。 在Java中，线程共享变量可以通过两种方式实现：静态成员变量和实例成员变量。静态成员属于类，所有该类的实例都可以访问，因此在多线程环境下默认共享...
java虚拟机多线程进阶篇总结
08-25
Java虚拟机多线程进阶篇总结是Java开发中一个非常重要的知识点，本节内容将会对Java虚拟机多线程进阶篇进行总结，帮助读者更好地理解Java虚拟机多线程的实现原理和应用。 一、线程池基本参数 在Java虚拟机中，...
Java多线程下解决资源竞争的7种方法详解
08-25
Java多线程下解决资源竞争的7种方法详解 Java 多线程编程中，资源竞争是一个非常重要的问题。随着多线程编程的增加，资源竞争的问题也变得越来越复杂。解决资源竞争的方法有很多种，这篇文章将介绍 Java 中解决...
JAVA专题技术综述之线程篇.rar_java 线程_java 线程
09-24
Java线程是并发编程的核心部分，它允许程序在同一时间执行多个任务，从而提高了系统资源的利用率和程序的响应速度。本专题将深入探讨Java中的线程技术，包括线程的创建、状态管理、同步机制以及相关API的使用。 在...
Java多线程工具篇BlockingQueue的详解
08-26
Java多线程工具篇BlockingQueue的详解 BlockingQueue是Java多线程工具篇中的一种高效安全的队列类，在多线程环境中扮演着关键角色。它能够高效解决多线程中数据传输的问题，使得数据由队列的一端输入，从另外一端...
VTK-vtkStructuredGrid学习
最新发布
weixin_69505365的博客
08-14 363
可以理解为单元格顺序沿着坐标轴排列，但是每个单元格可以不一样。维度理解为X/Y/Z方向的点数，如草图所示分别是4，3，1。此时只提供了12个点，只能构造一层，5.点图、线图、面图如下，对应行的代码改一下出现不同效果图。7.增加Z方向维度，点也要增加，点序保持一致。6.点可以不在同一个平面，随机改变点Z数值。2.获取这些点信息，点顺序要严格按照图示。直接赋值第一层的12个点，改一下Z值。所以Z方向维度是1，不能是其他数据。1.使用CAD随意绘制个网格草图。4.将上面的网格显示出来。
fme处理空间数据入门v0
weixin_43229258的博客
08-13 734
本教程是最最最基本的fme处理空间数据内容，给新同事介绍我以前是怎么干活用的，基本啥有用的东西。本教程主要说如何在 FME Workbench中创建模板文件（一般我们把fme写的工作空间就叫模板），教程里面主要是利用GIS数据。按照分步说明操作，1.了解如何从读取数据；2.添加转换器以在空间上过滤数据；3.将过滤后的数据写入 Esri Shapefile;4.如何运行模板文件。
8月13日学习笔记 LVS
weixin_70751701的博客
08-13 1096
目标地址散列调度算法先根据请求的目标IP地址，作为散列键 （Hash Key）从静态分配的散列表找出对应的服务器，若该服务器 是可用的且未超载，将请求发送到该服务器，否则返回空。1. 配置两个网卡和两个ip地址，正常来说应该配置两个不同的网段的 ip，一个对外的vip，一个对内的dip，现在主要使用nat的网络模 式，可以配置桥接模式对外，Nat对内，教师机不方便配置桥接模 式，所以都是配置的nat模式，但是一定要分清楚哪个ip是vip，哪个 ip是dip，在物理主机上都要能够ping通。
【Python】python中抽象类学习笔记
qq_42761751的博客
08-12 417
抽象类是一个不能被实例化的类，通常作为其他类的基类抽象方法是一个没有具体实现的方法一个抽象类可以有或者没有抽象方法, 但是一般来说定义抽象类的时候总会在类中定义抽象方法Python并没有直接支持抽象类，但是提供了一个模块（abc）来允许定义抽象类通过继承abc.ABC类定义一个抽象类pass上述代码中类虽然继承了ABC但是没有定义抽象方法，仍然可以被实例化。"""使用@abstractmethod来定义抽象方法"""passmain()代码报错：不能实例化一个带有抽象方法的抽象类。
Java线程详解：从入门到精通
"Java线程相关的学习资料，包括概念、原理和在Java中的实现与启动方法，适合初学者和进阶者。" 在深入探讨Java线程之前，我们需要理解操作系统中的基本...这篇学习笔记覆盖了这些基础知识，是Java线程学习的良好起点。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

打赏作者

二手Java程序员

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

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

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

打赏作者

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

抵扣说明：

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

余额充值