黑马程序员——java基础知识之多线程

最新推荐文章于 2021-02-16 08:11:22 发布
最新推荐文章于 2021-02-16 08:11:22 发布
阅读量434 收藏
点赞数
分类专栏： 黑马程序员技术博客 文章标签： 程序员 多线程 控制 启动 java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/king19910319/article/details/45498207
版权

——Java培训、Android培训、iOS培训、.Net培训、期待与您交流！ ——-
（一）、线程和进程的概念
进程：是一个正在执行中的程序。每一个进程执行都有一个执行顺序。该顺序是一个执行路径，或者叫一个控制单元。

线程：就是进程中的一个独立的控制单元。线程在控制着进程的执行。
注意：一个进程中至少有一个线程。

小例子说明：Java VM 启动的时候会有一个进程java.exe.

该进程中至少一个线程负责java程序的执行。
而且这个线程运行的代码存在于main方法中。
该线程称之为主线程。

扩展：其实更细节说明jvm，jvm启动不止一个线程，还有负责垃圾回收机制的线程。

（二）、线程的应用
1、创建线程的第一个方式
步骤：
①定义类继承Thread。
②复写Thread类中的run方法。
目的：将自定义代码存储在run方法。让线程运行。
③调用线程的start方法，
该方法两个作用：启动线程，调用run方法。

注意：为什么要覆盖run方法呢？
Thread类用于描述线程。
该类就定义了一个功能，用于存储线程要运行的代码。该存储功能就是run方法。

也就是说Thread类中的run方法，用于存储线程要运行的代码。

例子程序：

class Demo extends Thread
{
    public void run()
    {
        for(int x=0; x<60; x++)
            System.out.println("demo run----"+x);
    }
}

class ThreadDemo 
{
    public static void main(String[] args) 
    {
        Demo d = new Demo();//创建好一个线程。
        d.start();//开启线程并执行该线程的run方法。
        //d.run();//仅仅是对象调用方法。而线程创建了，并没有运行。

        for(int x=0; x<60; x++)
            System.out.println("Hello World!--"+x);
    }
}

2、线程的五种状态
被创建：等待启动，调用start启动。
运行状态：具有执行资格和执行权。
临时状态（阻塞）：有执行资格，但是没有执行权。
冻结状态：遇到sleep（time）方法和wait（）方法时，失去执行资格和执行权，sleep方法时间到或者调用notify（）方法时，获得执行资格，变为临时状态。
消忙状态：stop（）方法，或者run方法结束。
这里写图片描述

注意：
原来线程都有自己默认的名称。
Thread-编号 该编号从0开始。

static Thread currentThread():获取当前线程对象。
getName(): 获取线程名称。

设置线程名称：setName或者构造函数。

3、创建线程的第二种方式
实现Runable接口，步骤是：
步骤：
①定义类实现Runnable接口
②覆盖Runnable接口中的run方法。
将线程要运行的代码存放在该run方法中。

③通过Thread类建立线程对象。
④将Runnable接口的子类对象作为实际参数传递给Thread类的构造函数。
注意：为什么要将Runnable接口的子类对象传递给Thread的构造函数。
因为，自定义的run方法所属的对象是Runnable接口的子类对象。
所以要让线程去指定指定对象的run方法。就必须明确该run方法所属对象。
⑤调用Thread类的start方法开启线程并调用Runnable接口子类的run方法。

例子程序：

*/
class Ticket implements Runnable//extends Thread
{
    private  int tick = 100;
    public void run()
    {
        while(true)
        {
            if(tick>0)
            {               System.out.println(Thread.currentThread().getName()+"....sale : "+ tick--);
            }
        }
    }
}
class  TicketDemo
{
    public static void main(String[] args) 
    {
        Ticket t = new Ticket();
        Thread r = new Thread(t);
        t.start();
    }
}

重要：继承thread和实现runnable接口有什么区别？
实现的好处是解决了继承的局限性，继承只能是单继承，而是先可以是多实现。
继承thread类：代码存放在thread的子类的run方法中
实现runnable接口：代码存放在runnable接口的子类中

4、线程的安全问题
①安全问题的原因：
当多条语句在操作同一个线程共享数据时，一个线程对多条语句只执行了一部分，还没有执行完，另一个线程参与进来执行。导致共享数据的错误。
②解决办法：
对多条操作共享数据的语句，只能让一个线程都执行完。在执行过程中，其他线程不可以参与执行

Java对于多线程的安全问题提供了专业的解决方式同步。
同步方式一：同步代码块
格式：
synchronized(对象)
{
需要被同步的代码
}

*注意：同步的前提*
1，必须要有两个或者两个以上的线程。
2，必须是多个线程使用同一个锁。
好处：解决了多线程的安全问题。
弊端：多个线程需要判断锁，较为消耗资源。

例子程序：


class Ticket implements Runnable
{
    private  int tick = 1000;
    Object obj = new Object();
    public void run()
    {
        while(true)
        {
        //对多个线程操作共享数据时，加同步代码块
            synchronized(obj)
            {
                if(tick>0)
                {
                    //try{Thread.sleep(10);}catch(Exception e){}
                    System.out.println(Thread.currentThread().getName()+"....sale : "+ tick--);
                }
            }
        }
    }
}

同步方式二：同步函数
例子：

/*
需求：
银行有一个金库。
有两个储户分别存300员，每次存100，存3次。
目的：该程序是否有安全问题，如果有，如何解决？
如何找问题：
1，明确哪些代码是多线程运行代码。
2，明确共享数据。
3，明确多线程运行代码中哪些语句是操作共享数据的。
*/
lass Bank
{
    private int sum;
    //把synchronized加到函数中当成修饰符
    public synchronized void add(int n)
    {
            sum = sum + n;
            try{Thread.sleep(10);}catch(Exception e){}
            System.out.println("sum="+sum);
    }
}
//定义类继承rannable接口
class Cus implements Runnable
{
    private Bank b = new Bank();
    public void run()
    {       
        for(int x=0; x<3; x++)
        {
            b.add(100);
        }
    }
}
//开启线程
class  BankDemo
{
    public static void main(String[] args) 
    {
        Cus c = new Cus();
        Thread t1 = new Thread(c);
        Thread t2 = new Thread(c);
        t1.start();
        t2.start();
    }
}

注意：知识点
如果同步函数被静态修饰后，使用的锁是什么呢？

通过验证，发现不在是this。因为静态方法中也不可以定义this。
静态进内存是，内存中没有本类对象，但是一定有该类对应的字节码文件对象。
类名.class 该对象的类型是Class
静态的同步方法，使用的锁是该方法所在类的字节码文件对象。 类名.class

经典举例：
懒汉式

Single class{
    private Single s = null;
    private Single(){}
    public static Single getInstants(){
        //用双判断解决同步效率低的问题
        if(s==null){
        //用同步代码块来解决多线程的问题
        synchornized(Single.class){
            if(s==null)
            s= new Single();
        }
        }
        return s
    }
}

注意：同步中产生的问题：死锁
死锁：同步中嵌套同步。
例子死锁程序：

//创建线程，定义一个类实现runnable接口
class Test implements Runnable
{
    private boolean flag;
    Test(boolean flag)
    {
        this.flag = flag;
    }

    public void run()
    {
        if(flag)
        {
            while(true)
                {//一个同步有locka锁
                synchronized(MyLock.locka)
                {
                            System.out.println(Thread.currentThread().getName()+"...if locka ");
                    //同步里面还有一个同步，里面有一lockb锁
                    synchronized(MyLock.lockb)
                    {
                        System.out.println(Thread.currentThread().getName()+"..if lockb");                  
                    }
                }
            }
        }
        else
        {
            while(true)
            {
                //一个同步有lockb锁               
                synchronized(MyLock.lockb)
                {
                //同步里面还有一个同步，里面有一locka锁
                    synchronized(MyLock.locka)
                    {
                        System.out.println(Thread.currentThread().getName()+".....else locka");
                    }
                }
            }
        }
    }
}


class MyLock
{
    //定义两个锁
    static Object locka = new Object();
    static Object lockb = new Object();
}

class  DeadLockTest
{
    public static void main(String[] args) 
        {//创建两个线程对象，并开启线程
        Thread t1 = new Thread(new Test(true));
        Thread t2 = new Thread(new Test(false));
        t1.start();
        t2.start();
    }
}

4、多线程之间的通信
其实就是多个线程在操作同一个资源，但是操作的动作不同。
用例子说明：

package cn.dhjSyn;
/*
 * 多线程通信的安全问题和唤醒机制
 * 例子是有一个资源 
     一个线程往里存东西，如果里边没有的话 
       一个线程往里取东西，如果里面有得话 
 */

class Resourse{
    private String name;
    private String sex;
    private boolean flag = false;
    //同步输入函数，保证名字和性别一起输入和输出
    public synchronized void set(String name,String sex) {
        if(flag)
            //调wait方法，保证一个输入，就一个输出
            try{this.wait();}
            catch(Exception e){}
        this.name = name;
        this.sex = sex;
        this.flag = true;
        //叫醒输出的线程
        this.notify();
    }
    //同步输出函数
    public synchronized void out(){
        if(!flag)
            //调wait方法，保证一个输入，就一个输出
            try{this.wait();}
            catch(Exception e){}
        System.out.println(name+"....."+sex);
        this.flag=false;
        //叫醒输入线程
        this.notify();
    }
}
//定义输入线程的类
class Input implements Runnable{
    private Resourse r;
    Input(Resourse r){
        this.r=r;
    }
    public void run(){
        int x= 0;
        while(true){
            if(x==0)
                r.set("张婷婷", "女");
            else
                r.set("Mike", "nan");
            x = (x+1)%2;
        }
    }
} 
//定义输出线程的类
class Output implements Runnable{
    private Resourse r;
    Output(Resourse r){
        this.r=r;
    }
    public void run(){
        while(true)
            r.out();
    }
}

class ResourseDemo{
    public static void main(String[] args){
    Resourse r = new Resourse();
    //用匿名对象开启两个线程
    new Thread(new Input(r)).start();
    new Thread(new Output(r)).start();
    }
}

注意：
wait:
notify();
notifyAll();
都使用在同步中，因为要对持有监视器(锁)的线程操作。
所以要使用在同步中，因为只有同步才具有锁。

为什么这些操作线程的方法要定义Object类中呢？
因为这些方法在操作同步中线程时，都必须要标识它们所操作线程只有的锁，
只有同一个锁上的被等待线程，可以被同一个锁上notify唤醒。
不可以对不同锁中的线程进行唤醒。

也就是说，等待和唤醒必须是同一个锁。

而锁可以是任意对象，所以可以被任意对象调用的方法定义Object类中。

重点例子：
消费者问题：（一）利用同步和锁来实现

package cn.dhjSyn;
//开启线程
public class ProducerDemoTest {
    public static void main(String[] args){
        Resourse6 res = new Resourse6(); 
        Producer pro = new Producer(res);
        Cosumer cos = new Cosumer(res);
        Thread t1 = new Thread(pro);
        Thread t2 = new Thread(pro);
        Thread t3 = new Thread(cos);
        Thread t4 = new Thread(cos);
        t1.start();
        t2.start();
        t3.start();
        t4.start();
    }
}
//定义资源类
class Resourse6{
    private String name;
    private int count;
    //定义标记
    private boolean flag = false;
    //利用同步解决多线程的问题
    public synchronized void set(String name){
        while(flag)
            try{
                //生产一次就取消执行资格，进入等待状态
                this.wait();
            }catch(Exception e){

            }
        this.name=name+"....."+count++;
        System.out.println(Thread.currentThread().getName()+"生产者"+this.name);
        this.flag=true;
        //唤醒所有的等待线程
        this.notifyAll();
    }
    public synchronized void out(){
        while(!flag)
            try{
                this.wait();
            }catch(Exception e){

            }
        System.out.println(Thread.currentThread().getName()+"消费者"+this.name);
        this.flag=false;
        this.notifyAll();
    }
}
//定义生产者的类实现Runnable接口
class Producer implements Runnable{
    Resourse6 res;
    Producer(Resourse6 res){
        this.res=res;
    }
    //重写run方法
    public void run(){
        while(true)
            res.set("+商品+");
    }
}

class Cosumer implements Runnable{
    Resourse6 res;
    Cosumer(Resourse6 res){
        this.res=res;
    }
    public void run(){
        while(true)
            res.out();
    }
}

实现消费者问题的第二种方式：
JDK1.5 中提供了多线程升级解决方案。
将同步Synchronized替换成显示Lock操作。
将Object中的wait，notify notifyAll，替换了Condition对象。
该对象可以Lock锁 进行获取。
该示例中，实现了本方只唤醒对方操作。
Lock:替代了Synchronized
lock
unlock
newCondition()

Condition：替代了Object wait notify notifyAll
await();
signal();
signalAll();

class Resource
{
    private String name;
    private int count = 1;
    private boolean flag = false;
            //  t1    t2
    private Lock lock = new ReentrantLock();

    private Condition condition_pro = lock.newCondition();
    private Condition condition_con = lock.newCondition();



    public  void set(String name)throws InterruptedException
    {
        lock.lock();
        try
        {
            while(flag)
                condition_pro.await();//t1,t2
            this.name = name+"--"+count++;

            System.out.println(Thread.currentThread().getName()+"...生产者.."+this.name);
            flag = true;
            condition_con.signal();
        }
        finally
        {
            lock.unlock();//释放锁的动作一定要执行。
        }
    }


    //  t3   t4  
    public  void out()throws InterruptedException
    {
        lock.lock();
        try
        {
            while(!flag)
                condition_con.await();
            System.out.println(Thread.currentThread().getName()+"...消费者........."+this.name);
            flag = false;
            condition_pro.signal();
        }
        finally
        {
            lock.unlock();
        }

    }
}

class Producer implements Runnable
{
    private Resource res;

    Producer(Resource res)
    {
        this.res = res;
    }
    public void run()
    {
        while(true)
        {
            try
            {
                res.set("+商品+");
            }
            catch (InterruptedException e)
            {
            }

        }
    }
}

class Consumer implements Runnable
{
    private Resource res;

    Consumer(Resource res)
    {
        this.res = res;
    }
    public void run()
    {
        while(true)
        {
            try
            {
                res.out();
            }
            catch (InterruptedException e)
            {
            }
        }
    }
}

5、线程的中断（停止线程）：
stop方法已经过时。

如何停止线程？
只有一种，run方法结束。
开启多线程运行，运行代码通常是循环结构。

只要控制住循环，就可以让run方法结束，也就是线程结束。

特殊情况：
当线程处于了冻结状态。
就不会读取到标记。那么线程就不会结束。

当没有指定的方式让冻结的线程恢复到运行状态是，这时需要对冻结进行清除。
强制让线程恢复到运行状态中来。这样就可以操作标记让线程结束。

Thread类提供该方法 interrupt();

例子程序

class StopThread implements Runnable
{
    private boolean flag =true;
    public  void run()
    {
        while(flag)
        {
        try{
        //出现冻结状态
        wait();
        }catch(InterruptedException e){
        //被InterruptedException打醒后，改变标记，让线程结束。
        flag = false;           System.out.println(Thread.currentThread().getName());
        }
        }
    }
    public void changeFlag()
    {
        flag = false;
    }
}


class  StopThreadDemo
{
    public static void main(String[] args) 
    {
        StopThread st = new StopThread();

        Thread t1 = new Thread(st);
        Thread t2 = new Thread(st);


        t1.setDaemon(true);
        t2.setDaemon(true);
        t1.start();
        t2.start();

        int num = 0;

        while(true)
        {
            if(num++ == 60)
            {
                 st.changeFlag();
                 //t1和t2被强行打醒，从冻结状态变为运行状态
                 t1.interrupt();
                 t2.interrupt();
                break;
            }
            System.out.println(Thread.currentThread().getName()+"......."+num);
        }
        System.out.println("over");
    }
}

线程的其他方法之守护线程：
setDaemo(true)
该方法必须在启动线程前调用，而且当运行线程都是守护线程时，Java虚拟机自动退出。

线程的其他方法之join方法：
当A线程执行到了B线程的join（）方法时，A就会等待，等B线程都执行完A线程才会执行。
join（）用来临时加入线程执行

线程的其他方法之优先级和yield方法
线程可以设置优先级，优先级有1—10级，方法是setPriority（）；
线程的另一个方法yield（），暂停当前正在执行的线程对象，并执行其他线程。

线程在开发中应用的场景：
当有多个方法要被电脑同时执行时，可以通过多线程来实现

package cn.dhjSyn;

public class TestXianCheng {
    public static void main(String[] args){
        //用匿名内部类创建新的线程对象并调用start()方法，开启线程
        new Thread(){
            public  void run(){
                for(int x=0;x<60;x++){
                    System.out.println(Thread.currentThread().getName()+"....."+x);
                }
            }
        }.start();

        for(int x=0;x<70;x++){
            System.out.println(Thread.currentThread().getName()+"....."+x);
        }
        //第二种方式也是用匿名内部类，
        Runnable r = new Runnable(){
            public void run(){
                for(int x=0;x<80;x++){
                    System.out.println(Thread.currentThread().getName()+"....."+x);
                }
            }

        };
        new Thread(r).start();
    }
}
段黄军
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
黑马程序员入学Java知识——精华总结
03-07
1. **Java基础知识**：Java是一种面向对象的语言，它的基础包括语法、数据类型（如基本类型和引用类型）、运算符、控制结构（如if语句、switch语句、for循环、while循环）以及方法的定义和调用。 2. **类与对象**：...
八股文知识点汇总——Java面试题指南
01-05
以上只是Java面试题的一部分，涵盖了许多基础知识，对于Java程序员来说，深入理解这些概念和原理对于职业发展至关重要。其他面试题如集合、异常处理、IO/NIO、反射、序列化、注解、多线程并发、JVM优化、数据库技术...
java runnable 使用_如何调用java Runnable对象的其他方法？
weixin_34640046的博客
02-16 1165
任何编程语言中的任何方法都在与调用者相同的线程中执行.当你调用Thread.start()时,它会在调用它的同一个线程中运行.现在,您知道Thread的run()方法不会在与start相同的线程中执行.但那是因为start本身并不会调用run.您将不得不阅读更多有关线程的信息以获得完整的图片,但只是想象一下,start只创建一个带有一些数据结构的新线程(Runnable),新创建的线程查看该数据结...
Java并发编程笔记-自定义Runnable
cxmfzu的博客
07-23 749
Runnable Runnable 是一个接口，是线程的执行体。源码非常的简单。 public interface Runnable{ public abstract void run(); } 为了应对复杂的场景，需要对Runnable进行简单的自定义，下面就描述两种场景，已经我对这两种场景的思考。 场景1：获取线程（执行体）的执行结果。 场景2：优雅的停止线程。 获取线程（执行体）的执行结果 注意 本文中的执行体可能是Runnable 中的run方法或者Callable中的Call方法。线程的执行结
黑马程序员——Java基础知识之多线程协同
weixin_30583563的博客
05-14 88
android培训、java培训、期待与您交流！ 多线程协同 线程间的通讯：对资源的操作动作不同，比如说两个卡车一个拉煤一个装煤，但是他们共享了一个资源。 怎么样把这个资源拿出来？怎样把车装满？这个资源当然是一个类，他里面的组成元素就是对象！！现在我们就要有操作对象的思想了，用对象把这车装满，现在一车装一个对象...
黑马程序员——Java基础知识——多线程
ai272519的专栏
03-27 399
------Java培训、Android培训、iOS培训、.Net培训、期待与您交流！  多线程   要理解多线程，就必须理解线程。而要理解线程，就必须知道进程。 1、 进程         是一个正在执行的程序。         每一个进程执行都有一个执行顺序。该顺序是一个
黑马程序员——java基础之多线程
back
01-02 495
——- android培训、java培训、期待与您交流！ ———-java基础之多线程一. 多线程的概念1. 进程、线程和多线程： 进程：正在进行中的程序（直译）。进程是程序在某个数据集上的运行，它有自己的生命周期，因调度而运行。因等待资源或事件而被处于等待状态，因完成任务而被撤销。 线程：进程中一个负责程序执行的控制单元（执行路径）。是一个程序中的不同执行路径。一个进程中可以有多个执行路径，称之为
黑马程序员——java基础知识篇——>线程
cyn19880617的博客
09-11 306
-----------android培训、java培训、java学习型技术博客、期待与您交流！------------ 一、概述 进程：是一个正在执行中的程序，每一个进程执行都有一个执行顺序，该顺序是一个执行路径，或者叫一个控制单元 。 线程：就是进程中的一个独立的控制单元，线程在控制着进程的执行，一个进程中至少有一个进程 特点：java虚拟机启动的时候会有一个进程java.exe，该进程
黑马程序员————Java基础之多线程
jason_yang02的博客
12-18 197
多线程 进程与线程： 进程：是一个正在执行中的程序。每一个进程执行都有一个执行顺序。该顺序是一个执行路径，或者叫一个控制单元。一个进程至少有一个线程。 线程：就是进程中的一个独立的控制单元。  线程在控制着进程的执行。 Java VM  启动的时候会有一个进程java.exe。该进程中至少一个线程负责java程序的执行。而且这个线程运行的代码存在于main方法中。 该线程称之为主线程
黑马程序员——java基础——多线程（2）
Huberry的专栏
09-07 537
------Java培训、Android培训、iOS培训、.Net培训、期待与您交流！ -------   一、死锁 当同步中嵌套同步时，就有可能出现死锁现象。 代码示例： //写一个死锁程序  //定义一个类来实现Runnable，并复写run方法   class LockTest implements Runnable{     private boolean flag
黑马程序员——Java基础---多线程
Andriod爱好者
07-02 352
一、多线程概述         要理解多线程，就必须理解线程。而要理解线程，就必须知道进程。 1、 进程         是一个正在执行的程序。         每一个进程执行都有一个执行顺序。该顺序是一个执行路径，或者叫一个控制单元。 2、线程          就是进程中的一个独立的控制单元。线程在控制着进程的执行。只要进程中有一个线程在执行，进程就不会结束
黑马程序员_(适合初学者入门的Java基础视频)
08-24
"黑马程序员_（适合初学者入门的Java基础视频）"是一套专为初学者设计的Java基础教学课程，旨在帮助零基础的学习者逐步掌握Java编程的基本概念和技能。 该视频教程涵盖了Java的基础知识，包括： 1. **环境搭建**：...
2018-2019年黑马最新版Java程序员面试宝典+题库pdf
03-26
这份资料主要针对初级Java程序员，旨在帮助他们巩固基础知识，掌握面试技巧，以便在求职过程中脱颖而出。 Java程序员面试宝典涵盖的知识点广泛，主要包括以下几个方面： 1. **基础语法**：包括变量、数据类型、...
java视频教程_黑马Java零基础辅导班[第二期]09天课件源码
12-18
《Java编程之旅：黑马程序员零基础辅导班课程详解》 在IT行业中，Java语言以其强大的跨平台能力和丰富的库支持，始终占据着重要的地位。对于初学者来说，掌握Java开发技术是进入这个领域的关键一步。本教程针对零...
黑马程序员——Java基础知识之DUI（图形用户界面）
king19910319的专栏
05-16 922
——Java培训、Android培训、iOS培训、.Net培训、期待与您交流！ ——- （一）什么GUI？ 1、图形用户界面，用于计算机与用户交互的一种方式，英文是GraphicalUser Interface2、javaGUI： java也将这种界面封装为对象，其中的对象都放在了两个包中：java.Awt包和javax.Swing包。 ava.Awt包：Abstract Window To
黑马程序员——java基础知识之泛型、集合（Map、工具类等）
king19910319的专栏
05-09 712
——Java培训、Android培训、iOS培训、.Net培训、期待与您交流！ ——- （一）、泛型
黑马程序员——java基础知识之集合框架(容器)
king19910319的专栏
05-08 543
——Java培训、Android培训、iOS培训、.Net培训、期待与您交流！ ——- 1、为什么出现集合框架？ 面向对象语言对事物的体现都是以对象的形式，所以为了方便对多个对象的操作，就对对象进行存储，集合就是存储对象最常用的一种方式。2、图解集合框架的构成 3、Collection集合的主要方法 Collection定义了集合框架的共性功能。 1，添加 add(e);
黑马程序员——java基础知识之网络编程（一）
king19910319的专栏
04-14 541
——Java培训、Android培训、iOS培训、.Net培训、期待与您交流！ ——- （一）、网络编程的基础知识 1、网络编程的目的是什么？ 就是为了实现直接或间接地通过网络与其他计算机进行通信。 2、要想实现网络编程要素 ①找到对方的IP ②数据要发送到对方电脑上的应用程序，为了标示这些应用程序，所给这些网络应用程序都给数字标示，这些数字就叫做端口，它们是逻辑端口 ③定义通信规则

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值