Java_07 快速入门 多线程

最新推荐文章于 2024-07-13 15:10:29 发布
最新推荐文章于 2024-07-13 15:10:29 发布
阅读量77 收藏
点赞数 1
分类专栏： Java 文章标签： p2p linq 网络协议 Java多线程 线程问题
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_60786924/article/details/125357892
版权

目录

第一章：多线程

1.2  多线程实现

范例1-1：定义一个线程操作类。

范例1-2：启动多线程。

范例1-3：start()方法的源代码。

范例1-4：使用Runnable实现多线程。

范例1-5：利用Thread类启动多线程。

范例1-6：使用Lamda表达式实现多线程。

范例1-7：通过继承Thread类实现卖票程序。

范例1-8：利用Runnable接口来实现多线程。

范例1-9：使用Thread类实现数据共享的概念。

范例1-10：定义一个线程主体类。

范例1-11：启动多线程。

1.3  多线程常用操作方法

范例1-12：观察线程的命名。

范例1-13：取得线程名字。

范例1-14：观察休眠特点。

范例1-15：设置线程优先级。

范例1-16：主方法优先级。

范例1-17：观察非同步情况下的操作。

范例1-18：观察同步块。

范例1-19：使用同步方法解决问题。

范例1-20：程序死锁操作。

1.5  线程间的经典操作案例——生产者与消费者案例

范例1-21：程序基本模型。

范例1-22：加入同步，解决数据错乱问题。

范例1-23：解决程序问题。

1.6  线程的生命周期

范例1-24：停止线程运行。

第一章：多线程

1.2  多线程实现

范例1-1：定义一个线程操作类。

class MyThread extends Thread { // 这就是一个多线程的操作类

private String name ; // 定义类中的属性

public MyThread(String name) { // 定义构造方法

this.name = name ;

}

@Override

public void run() { // 覆写run()方法，作为线程的主操作方法

for (int x = 0 ; x < 200 ; x ++) {

System.out.println(this.name + " --> " + x);

}

}

}

范例1-2：启动多线程。

public class TestDemo { // 主类

public static void main(String[] args) {

MyThread mt1 = new MyThread("线程A") ; // 实例化多线程类对象

MyThread mt2 = new MyThread("线程B") ; // 实例化多线程类对象

MyThread mt3 = new MyThread("线程C") ; // 实例化多线程类对象

mt1.start(); // 启动多线程

mt2.start(); // 启动多线程

mt3.start(); // 启动多线程

}

}

范例1-3：start()方法的源代码。

public synchronized void start() {

    if (threadStatus != 0)

      throw new IllegalThreadStateException();

    group.add(this);

    boolean started = false;

    try {

        start0();

        started = true;

    } finally {

      try {

          if (!started) {

            group.threadStartFailed(this);

          }

      } catch (Throwable ignore) {

      }

   }

}

private native void start0();

范例1-4：使用Runnable实现多线程。

class MyThread implements Runnable { // 定义线程主体类

private String name; // 定义类中的属性

public MyThread(String name) { // 定义构造方法

this.name = name;

}

@Override

public void run() { // 覆写run()方法

for (int x = 0; x < 200; x++) {

System.out.println(this.name + " --> " + x);

}

}

}

范例1-5：利用Thread类启动多线程。

public class TestDemo {

public static void main(String[] args) {

MyThread mt1 = new MyThread("线程A") ; // 实例化多线程类对象

MyThread mt2 = new MyThread("线程B") ; // 实例化多线程类对象

MyThread mt3 = new MyThread("线程C") ; // 实例化多线程类对象

new Thread(mt1).start(); // 利用Thread启动多线程

new Thread(mt2).start(); // 利用Thread启动多线程

new Thread(mt3).start(); // 利用Thread启动多线程

}

}

范例1-6：使用Lamda表达式实现多线程。

public class TestDemo {

public static void main(String[] args) {

String name = "线程对象" ;

new Thread(() -> {

for (int x = 0; x < 200; x++) {

System.out.println(name + " --> " + x);

}

}).start();;

}

}

范例1-7：通过继承Thread类实现卖票程序。

package com.yootk.demo;

class MyThread extends Thread { // 线程的主体类

private int ticket = 5; // 一共5张票

@Override

public void run() { // 线程的主方法

for (int x = 0; x < 50; x++) { // 循环50次

if (this.ticket > 0) {

System.out.println("卖票，ticket = " + this.ticket --);

}

}

}

}

public class TestDemo {

public static void main(String[] args) throws Exception {

MyThread mt1 = new MyThread() ; // 创建线程对象

MyThread mt2 = new MyThread() ; // 创建线程对象

MyThread mt3 = new MyThread() ; // 创建线程对象

mt1.start() ; // 启动线程

mt2.start() ; // 启动线程

mt3.start() ; // 启动线程

}

}

范例1-8：利用Runnable接口来实现多线程。

package com.yootk.demo;

class MyThread implements Runnable { // 线程的主体类

private int ticket = 5; // 一共5张票

@Override

public void run() { // 线程的主方法

for (int x = 0; x < 50; x++) { // 循环50次

if (this.ticket > 0) {

System.out.println("卖票，ticket = " + this.ticket --);

}

}

}

}

public class TestDemo {

public static void main(String[] args) throws Exception {

MyThread mt = new MyThread(); // 创建线程对象

new Thread(mt).start() ; // 启动线程

new Thread(mt).start() ; // 启动线程

new Thread(mt).start() ; // 启动线程

}

}

范例1-9：使用Thread类实现数据共享的概念。

package com.yootk.demo;

class MyThread extends Thread { // 线程的主体类

private int ticket = 5; // 一共5张票

@Override

public void run() { // 线程的主方法

for (int x = 0; x < 50; x++) { // 循环50次

if (this.ticket > 0) {

System.out.println("卖票，ticket = " + this.ticket --);

}

}

}

}

public class TestDemo {

public static void main(String[] args) throws Exception {

MyThread mt = new MyThread(); // 创建线程对象

new Thread(mt).start() ; // 启动线程

new Thread(mt).start() ; // 启动线程

new Thread(mt).start() ; // 启动线程

}

}

范例1-10：定义一个线程主体类。

import java.util.concurrent.Callable;

class MyThread implements Callable<String> { // 多线程主体类

private int ticket = 10; // 卖票

@Override

public String call() throws Exception {

for (int x = 0; x < 100; x++) {

if (this.ticket > 0) { // 还有票可以出售

System.out.println("卖票，ticket = " + this.ticket--);

}

}

return "票已卖光！"; // 返回结果

}

}

范例1-11：启动多线程。

public class TestDemo {

public static void main(String[] args) throws Exception {

MyThread mt1 = new MyThread(); // 实例化多线程对象

MyThread mt2 = new MyThread(); // 实例化多线程对象

FutureTask<String> task1 = new FutureTask<String>(mt1) ;

FutureTask<String> task2 = new FutureTask<String>(mt2) ;

// FutureTask是Runnable接口子类，所以可以使用Thread类的构造来接收task对象

new Thread(task1).start(); // 启动第一个线程 

new Thread(task2).start(); // 启动第二个线程

// 多线程执行完毕后可以取得内容，依靠FutureTask的父接口Future中的get()方法实现

System.out.println("A线程的返回结果：" + task1.get());

System.out.println("B线程的返回结果：" + task2.get());

}

}

1.3  多线程常用操作方法

范例1-12：观察线程的命名。

package com.yootk.demo;

class MyThread implements Runnable {

@Override

public void run() {

System.out.println(Thread.currentThread().getName());

}

}

public class TestDemo {

public static void main(String[] args) throws Exception {

MyThread mt = new MyThread();

new Thread(mt, "自己的线程A").start();

new Thread(mt).start();

new Thread(mt, "自己的线程B").start();

new Thread(mt).start();

new Thread(mt).start();

}

}

范例1-13：取得线程名字。

package com.yootk.demo;

class MyThread implements Runnable {

@Override

public void run() {

System.out.println(Thread.currentThread().getName());

}

}

public class TestDemo {

public static void main(String[] args) throws Exception {

MyThread mt = new MyThread();

new Thread(mt, "自己的线程对象").start();

mt.run(); // 直接调用run()方法，main

}

}

范例1-14：观察休眠特点。

package com.yootk.demo;

class MyThread implements Runnable {

@Override

public void run() {

for (int x = 0; x < 10000; x++) {

try {

Thread.sleep(1000); // 每次执行休眠1s

} catch (InterruptedException e) {

e.printStackTrace();

}

System.out.println(Thread.currentThread().getName() + "，x = " + x);

}

}

}

public class TestDemo {

public static void main(String[] args) throws Exception {

MyThread mt = new MyThread();

new Thread(mt, "自己的线程对象A").start();

}

}

范例1-15：设置线程优先级。

package com.yootk.demo;

class MyThread implements Runnable {

@Override

public void run() {

for (int x = 0; x < 20; x++) {

try {

Thread.sleep(100);

} catch (InterruptedException e) {

e.printStackTrace();

}

System.out.println(Thread.currentThread().getName() + "，x = " + x);

}

}

}

public class TestDemo {

public static void main(String[] args) throws Exception {

MyThread mt = new MyThread();

Thread t1 = new Thread(mt, "自己的线程对象A");

Thread t2 = new Thread(mt, "自己的线程对象B");

Thread t3 = new Thread(mt, "自己的线程对象C");

T3.setPriority(Thread.MAX_PRIORITY); // 修改一个线程对象的优先级

t1.start();

t2.start();

t3.start();

}

}

范例1-16：主方法优先级。

public class TestDemo {

public static void main(String[] args) throws Exception {

System.out.println(Thread.currentThread().getPriority());

}

}

范例1-17：观察非同步情况下的操作。

package com.yootk.demo;

class MyThread implements Runnable {

private int ticket = 5; // 一共有5张票

@Override

public void run() {

for (int x = 0; x < 20; x++) {

if (this.ticket > 0) { // 判断当前是否还有剩余票

try {

Thread.sleep(100); // 休眠1s，模拟延迟

} catch (InterruptedException e) {

e.printStackTrace();

}

System.out.println(Thread.currentThread().getName()

+ " 卖票，ticket = " + this.ticket--);

}

}

}

}

public class TestDemo {

public static void main(String[] args) throws Exception {

MyThread mt = new MyThread();

new Thread(mt, "票贩子A").start(); // 启动多线程

new Thread(mt, "票贩子B").start(); // 启动多线程

new Thread(mt, "票贩子C").start(); // 启动多线程

new Thread(mt, "票贩子D").start(); // 启动多线程

}

}

范例1-18：观察同步块。

package com.yootk.demo;

class MyThread implements Runnable {

private int ticket = 5; // 一共有5张票

@Override

public void run() {

for (int x = 0; x < 20; x++) {

synchronized(this) { // 定义同步代码块

if (this.ticket > 0) { // 判断当前是否还有剩余票

try {

Thread.sleep(100); // 休眠1s，模拟延迟

} catch (InterruptedException e) {

e.printStackTrace();

}

System.out.println(Thread.currentThread().getName()

+ " 卖票，ticket = " + this.ticket--);

}

}

}

}

}

public class TestDemo {

public static void main(String[] args) throws Exception {

MyThread mt = new MyThread();

new Thread(mt, "票贩子A").start(); // 启动多线程

new Thread(mt, "票贩子B").start(); // 启动多线程

new Thread(mt, "票贩子C").start(); // 启动多线程

new Thread(mt, "票贩子D").start(); // 启动多线程

}

}

范例1-19：使用同步方法解决问题。

package com.yootk.demo;

class MyThread implements Runnable {

private int ticket = 5; // 一共有5张票

@Override

public void run() {

for (int x = 0; x < 20; x++) {

this.sale(); // 卖票操作

}

}

public synchronized void sale() { // 同步方法

if (this.ticket > 0) { // 判断当前是否还有剩余票

try {

Thread.sleep(100); // 休眠1s，模拟延迟

} catch (InterruptedException e) {

e.printStackTrace();

}

System.out.println(Thread.currentThread().getName()

+ " 卖票，ticket = " + this.ticket--);

}

}

}

public class TestDemo {

public static void main(String[] args) throws Exception {

MyThread mt = new MyThread();

new Thread(mt, "票贩子A").start(); // 启动多线程

new Thread(mt, "票贩子B").start(); // 启动多线程

new Thread(mt, "票贩子C").start(); // 启动多线程

new Thread(mt, "票贩子D").start(); // 启动多线程

}

}

范例1-20：程序死锁操作。

package com.yootk.demo;

class A {

public synchronized void say(B b) {

System.out.println("A先生说：把你的本给我，我给你笔，否则不给！");

b.get();

}

public synchronized void get() {

System.out.println("A先生：得到了本，付出了笔，还是什么都干不了！");

}

}

class B {

public synchronized void say(A a) {

System.out.println("B先生说：把你的笔给我，我给你本，否则不给！");

a.get();

}

public synchronized void get() {

System.out.println("B先生：得到了笔，付出了本，还是什么都干不了！");

}

}

public class TestDemo implements Runnable {

private static A a = new A(); // 定义类对象

private static B b = new B(); // 定义类对象

public static void main(String[] args) throws Exception {

new TestDemo(); // 实例化本类对象

}

public TestDemo() { // 构造方法

new Thread(this).start(); // 启动线程

b.say(a); // 互相引用

}

@Override

public void run() {

a.say(b); // 互相引用

}

}

1.5  线程间的经典操作案例——生产者与消费者案例

范例1-21：程序基本模型。

package com.yootk.demo;

class Message {

private String title ; // 保存信息的标题

private String content ; // 保存信息的内容

public void setTitle(String title) {

this.title = title;

}

public void setContent(String content) {

this.content = content;

}

public String getTitle() {

return title;

}

public String getContent() {

return content;

}

}

class Producer implements Runnable { // 定义生产者

private Message msg = null ;

public Producer(Message msg) {

this.msg = msg ;

}

@Override

public void run() {

for (int x = 0; x < 50; x++) { // 生产50次数据

if (x % 2 == 0) {

this.msg.setTitle("李兴华") ; // 设置title属性

try {

Thread.sleep(100) ; // 延迟操作

} catch (InterruptedException e) {

e.printStackTrace();

}

this.msg.setContent("Java讲师") ; // 设置content属性

} else {

this.msg.setTitle("mldn") ; // 设置title属性

try {

Thread.sleep(100) ;

} catch (InterruptedException e) {

e.printStackTrace();

}

this.msg.setContent("www.mldnjava.cn") ; // 设置content属性

}

}

}

}

class Consumer  implements Runnable { // 定义消费者

private Message msg = null ;

public Consumer (Message msg) {

this.msg = msg ;

}

@Override

public void run() {

for (int x = 0; x < 50; x++) { // 取走50次数据

try {

Thread.sleep(100) ; // 延迟

} catch (InterruptedException e) {

e.printStackTrace();

}

System.out.println(this.msg.getTitle() + " --> " + this.msg.getContent());

}

}

}

public class TestDemo {

public static void main(String[] args) throws Exception {

Message msg = new Message() ; // 定义Message对象，用于保存和取出数据

new Thread(new Producer(msg)).start() ; // 启动生产者线程

new Thread(new Consumer(msg)).start() ; // 取得消费者线程

}

}

范例1-22：加入同步，解决数据错乱问题。

package com.yootk.demo;

class Message {

private String title ; // 保存信息的标题

private String content ; // 保存信息的内容

public synchronized void set(String title, String content) {

this.title = title;

try {

Thread.sleep(200);

} catch (InterruptedException e) {

e.printStackTrace();

}

this.content = content;

}

public synchronized void get() {

try {

Thread.sleep(100);

} catch (InterruptedException e) {

e.printStackTrace();

}

System.out.println(this.title + " --> " + this.content);

}

// setter、getter略

}

class Producer implements Runnable { // 定义生产者

private Message msg = null ;

public Producer(Message msg) {

this.msg = msg ;

}

@Override

public void run() {

for (int x = 0; x < 50; x++) { // 生产50次数据

if (x % 2 == 0) {

this.msg.set("李兴华","Java讲师") ; // 设置属性

} else {

this.msg.set("mldn","www.mldnjava.cn") ; // 设置属性

}

}

}

}

class Consumer  implements Runnable { // 定义消费者

private Message msg = null ;

public Consumer (Message msg) {

this.msg = msg ;

}

@Override

public void run() {

for (int x = 0; x < 50; x++) { // 取走50次数据

this.msg.get() ; // 取得属性

}

}

}

public class TestDemo {

public static void main(String[] args) throws Exception {

Message msg = new Message() ; // 定义Message对象，用于保存和取出数据

new Thread(new Producer(msg)).start() ; // 启动生产者线程

new Thread(new Consumer(msg)).start() ; // 取得消费者线程

}

}

范例1-23：解决程序问题。

class Message {

private String title;

private String content;

private boolean flag = true;

// flag == true：表示可以生产，但是不能取走

// flag == false：表示可以取走，但是不能生产

public synchronized void set(String title, String content) {

if (this.flag == false) { // 已经生产过了，不能生产

try {

super.wait(); // 等待

} catch (InterruptedException e) {

e.printStackTrace();

}

}

this.title = title;

try {

Thread.sleep(200);

} catch (InterruptedException e) {

e.printStackTrace();

}

this.content = content;

this.flag = false; // 已经生产完成，修改标志位

super.notify(); // 唤醒等待线程

}

public synchronized void get() {

if (this.flag == true) { // 未生产，不能取走

try {

super.wait(); // 等待

} catch (InterruptedException e) {

e.printStackTrace();

}

}

try {

Thread.sleep(100);

} catch (InterruptedException e) {

e.printStackTrace();

}

System.out.println(this.title + " --> " + this.content);

this.flag = true; // 已经取走了，可以继续生产

super.notify(); // 唤醒等待线程

}

// setter、getter略

}

1.6  线程的生命周期

范例1-24：停止线程运行。

package com.yootk.demo;

class MyThread implements Runnable {

private boolean flag = true; // 定义标志位属性

public void run() { // 覆写run()方法

int i = 0;

while (this.flag) { // 循环输出

while (true) {

System.out.println(Thread.currentThread().getName() + "运行，i = "

+ (i++)); // 输出当前线程名称

}

}

}

public void stop() { // 编写停止方法

this.flag = false; // 修改标志位

}

}

public class StopDemo {

public static void main(String[] args) {

MyThread my = new MyThread(); // 实例化Runnable接口对象

Thread t = new Thread(my, "线程"); // 建立线程对象

t.start() ; // 启动线程

my.stop() ; // 线程停止，修改标志位

}

}

£轻描～淡写°
关注
  • 1
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
【Java基础知识 1】Java入门级概述
学Java，找哪吒
09-25 15万+
CSDN最强Java专栏，包含全部Java基础知识点、Java8新特性、Java集合、Java多线程、Java代码实例，理论结合实战，实现Java的轻松学习。
JavaSE——07多线程
胖虎虎
07-14 280
​ 当在DOS命令窗口中输入：java HelloWorld 回车之后。会先启动JVM，而JVM就是一个进程。JVM再启动一个主线程调用main方法。同时再启动一个垃圾回收线程负责看护，回收垃圾。最起码，现在的java程序中至少有两个线程并发，一个是垃圾回收线程，一个是执行main方法的主线程。阿里巴巴：进程 马云：阿里巴巴的一个线程 童文红：阿里巴巴的一个线程京东：进程 强东：京东的一个线程 妹妹：京东的一个线程进程可以看做是现实生活当中的公司。 线程可以看做是公司当中的某个员工。注意： 进程A和进程B的
rabbitmq java 多线程_RabbitMQ入门_05_多线程消费同一队列
weixin_39667652的博客
02-16 2071
A. 多线程消费同一队列消费一条消息往往比产生一条消息慢很多，为了防止消息积压，一般需要开启多个工作线程同时消费消息。在 RabbitMQ 中，我们可以创建多个 Consumer 消费同一队列。示意图如下：gordon.study.rabbitmq.workqueue.Sender.javapublic class Sender {private static final String QUEUE...
Java多线程学习（吐血超详细总结）
热门推荐
Evankaka的专栏
03-14 41万+
本文主要讲了java中多线程的使用方法、线程同步、线程数据传递、线程状态及相应的一些线程函数用法、概述等。
编程必备：JAVA多线程详解
拾一二的博客
06-14 7865
多线程已经成为一种常见的编程模式，广泛应用于各种不同类型的应用程序中。本篇博客文章中，我们将会探讨多线程编程的相关知识和技巧。通过代码示例和实际应用案例来深入了解多线程的具体实现和应用方法，帮助更好地掌握多线程编程技术，提高程序效率和性能。后期随学习深入还会补充修改。以上就是我对多线程的个人简介，后续会不断完善更新，与大家共勉。
Java编程迅速入门_如何快速入门Java
weixin_39805720的博客
02-17 1657
一、掌握静态方法和属性静态方法和属性用于描述某一类对象群体的特征，而不是单个对象的特征。Java中大量应用了静态方法和属性，这是一个通常的技巧。但是这种技巧在很多语言中不被频繁地使用。理解静态方法和属性对于理解类与对象的关系是十分有帮助的，在大量的Java规范中，静态方法和属性被频繁使用。因此学习者应该理解静态方法和属性。Java在方法和属性的调用上是一致的，区别只表现在声明的时候，这和c++是不...
013jmu-Java-07多线程-PrintTask
ihopeyousuccess的博客
11-30 4716
编写PrintTask类实现Runnable接口。 功能：输出从0到n-1的整数(n在创建PrintTask对象的时候指定)。并在最后使用System.out.println(Thread.currentThread().getName());输出标识信息。 裁判测试程序： import java.util.Scanner; /这里放置你的答案，即PrintTask类的代码/ public class Main { public static void main(String[] args) { Scann
java--JUC快速入门（彻底搞懂JUC）
weixin_43888181的博客
05-08 10万+
java–JUC快速入门（彻底搞懂JUC） 文章目录java--JUC快速入门（彻底搞懂JUC）1、学习多线程之前需要知道的一些概念。2、JUC的结构3、Lock锁(重点)4、集合类不安全5、Callable()6、常用的辅助类7、读写锁8、阻塞队列9、线程池 1、学习多线程之前需要知道的一些概念。 1.1 JUC是什么？ JUC是java.util.concurrent包的简称，在Java5.0添加，目的就是为了更好的支持高并发任务。让开发者进行多线程编程时减少竞争条件和死锁的问题！...
多线程快速入门
qq_38065439的博客
01-16 2万+
一，线程与进程的区别 每个正在系统上运行的程序都是一个进程。每个进程包含一到多个线程。 进程就是所有线程的集合，每个一个线程是进程中的一条执行路径 二，多线程创建方式 第一种:继承Thread类重写run方法 class CreateThread extends Thread { public void run() { for(int i = 0; i&lt;10...
Java 快速入门
qq_55202378的博客
09-25 3094
java快速入门
JAVA多线程入门基础知识
02-22
必知必会的多线程入门基础知识
java基础知识入门_java_world_入门_
09-30
Java是世界上最流行的...以上只是Java基础知识的一部分，随着学习的深入，你将接触到更多高级概念，如IO流、多线程、网络编程、数据库连接、设计模式等。Java World充满了无尽的可能性，欢迎踏入这个精彩的编程世界。
dq.zip_java 入门_java入门
09-14
9. **多线程**：Java支持多线程编程，使程序能同时执行多个任务。初学者需要了解Thread类和Runnable接口，以及同步机制如synchronized关键字和Lock接口。 10. **Java标准库（API）**：Java提供丰富的内置类和接口，...
java多线程入门的源代码
03-28
Java多线程是Java开发中的重要概念，它允许程序同时执行多个任务，提高了程序的效率和响应速度。在Java中，实现多线程有两种主要方式：继承Thread类和实现Runnable接口。 1. 继承Thread类： 当一个类继承了Thread...
[Java]三分钟入门多线程
12-21
我就是当时没有打好基础，最后学习Java web、Java框架的时候对这些东西很难有深刻的理解，所以我不得不回头来恶补基础。今天我们就来谈谈并发那些事。 并发 并发就是将程序划分为多个任务，每个任务可以在同一时间内...
frp内网穿透xtcp安全点对点p2p部署记录打洞失败解决方法
shaoqiu.wu的博客
07-09 388
所有服务启动后，且日志提示成功，安卓手机访问127.0.0.1:6000，这个时候再去看安卓frpc日志会提示STUN服务器查询失败，下面是奇葩的解决方法。一、有公网IP、linux主机（需要穿透里面的服务）、安卓手机、frps、frpc、安卓版frpc。二、两端frpc必须要有一端nat网络类型不是非对称nat。由于环境限制，教程比较粗糙，后期有时间会再细化。linux主机端frpc.toml配置。有公网的主机上配置frps.toml。
frp内网穿透ssh，tcp经过服务器慢速和p2p模式实现高速吃满上传带宽
cyuyan的专栏
07-13 157
frp服务器目前使用中，如果没云服务器，可以借道从上面服务器中转，有问题可以留言。这里如果不配置frp客户端，可以使用服务端ip 和 3322端口直接中转到目标。这样，就可以ssh客户端连接 127.0.0.1:3323 直连办公电脑了。办公室 云服务器 家。在家里经过云服务器中转，很慢，但是很稳定。使用p2p穿透，速度可以直接拉满。然后就是家里的ssh客户端配置。然后是中间的云服务器配置。
Kafka 典型问题与排查以及相关优化
qq_54188720的博客
07-09 1112
Kafka 是一个高吞吐量的分布式消息系统，但在实际应用中，用户经常会遇到一些性能问题和消息堆积的问题。本文将介绍 Kafka 中一些典型问题的原因和排查方法，帮助用户解决问题并优化 Kafka 集群的性能。
Kylin系列（八）实时分析：实现 Kylin 实时数据处理
最新发布
07-13 511
在当今的商业环境中，实时数据处理成为越来越多企业的迫切需求。无论是金融、电子商务，还是物联网应用，都需要对海量数据进行实时分析以快速响应业务需求。Apache Kylin作为一个开源的OLAP引擎，提供了高效的多维分析能力，但其原生设计主要面向批处理场景。通过一定的配置和优化，可以实现Kylin的实时数据处理，满足业务对实时分析的需求。本文将重点介绍如何实现Kylin的实时数据处理，包括数据流配置、实时Cube构建、查询优化等方面。
javase之多线程技术
10-16
多线程相关知识 相关说明 标题：<Java进阶课程之并发编程快速入门与多线程实战项目> 课程内容： 1.CPU调度算法原理（先来先服务、最短作业法、优先级调度算法） 2.站在字节码角度+cpu上下文切换角度分析线程安全问题 3.手写Callable与FutureTask模式 两种方式 4.并发编程实战案例之手写并发队列日志框架

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值