Java学习10-多线程-2

其他 2019-05-04 21:41:08 阅读次数: 0

Java学习10-多线程-2

文章目录

3 线程的生命周期

  • JDK 中用Thread.State 类定义了线程的几种状态
    要想实现多线程，必须在主线程中创建新的线程对象。Java语言使用Thread类及其子类的对象来表示线程，在它的一个完整的生命周期中通常要经历如下的五种状态：
  1. 新建： 当一个Thread类或其子类的对象被声明并创建时，新生的线程对象处于新建状态
  2. 就绪：处于新建状态的线程被start()后，将进入线程队列等待CPU时间片，此时它已具备了运行的条件，只是没分配到CPU资源
  3. 运行：当就绪的线程被调度并获得CPU资源时,便进入运行状态， run()方法定义了线程的操作和功能
  4. 阻塞：在某种特殊情况下，被人为挂起或执行输入输出操作时，让出 CPU 并临时中止自己的执行，进入阻塞状态
  5. 死亡：线程完成了它的全部工作或线程被提前强制性地中止或出现异常导致结束
    在这里插入图片描述

4 线程的同步

4.1多线程出现安全问题的原因：

当多条语句在操作同一个线程共享数据时，一个线程对多条语句只执行了一部分，还没有执行完，另一个线程参与进来执行。导致共享数据的错误。

4.2 解决办法：Synchronized

对多条操作共享数据的语句，只能让一个线程都执行完，在执行过程中，其他线程不可以参与执行。
在Java中，我们通过同步机制，来解决线程的安全问题。

4.2.1方式一：同步代码块

synchronized (同步监视器){
// 需要被同步的代码；
}
  • 需要被同步的代码：操作共享数据的代码。即为需要被同步的代码。（线程的同步，只有在一个线程执行完之后另一个线程才可以继续执行。线程的互斥，多个线程抢占一个资源）
  • 共享数据：多个线程共同操作的变量。比如：下例中的ticket就是共享数据
  • 同步监视器：俗称：锁。任何一个类的对象都可以充当锁。【要求】多个线程必须要共用一把锁。

同步锁机制：对于并发工作，需要某种方式来防止两个任务访问相同的资源（其实就是共享资源竞争）。 防止这种冲突的方法就是当资源被一个任务使用时，在其上加锁。第一个访问某项资源的任务必须锁定这项资源，使其他任务在其被解锁之前，就无法访问它了，而在其被解锁之时，另一个任务就可以锁定并使用它了。

【例1】使用同步代码块解决Runnable接口方式的线程安全问题
【改进】以下代码也可以不new一个Object对象，然后将synchronized (obj) 改为synchronized (this)即可。
这里的this是w1（推荐方式）

/**
 * 例：创建三个窗口卖票，总票数为100张,使用Runnable接口的方式
 * <p>
 * 1.问题：卖票过程中，出现了重票、错票-->出现了线程的安全问题
 * 2.出现问题的原因：当某个线程操作车票的过程中，尚未操作完成时，其他线程参与进来，也操作车票。
 * 3.如何解决：当一个线程A在操作ticket的时候，其他线程不能参与进来，直到线程A操作完ticket时，其它线程才可以操作ticket
 * 即使线程A出现了阻塞，也不能改变。
 * 4.在Java中，我们通过同步机制，来解决安全问题。
 * 注意：多个线程必须共用同一把锁。
 */

class Window1 implements Runnable {

    private int ticket = 100;//此处的ticket不用定义为static，因为只nwe了一个Window1，w1作为参数给Thread构造器
    //t1,t2,t3公用一个ticket
    private Object obj = new Object();

    @Override
    public void run() {

        while (true) {
            synchronized (obj) { //三个线程共用一个Window1对象，Window1对象中只new了一个Object，多个线程共用一把锁：obj
                /**
                 * 以下需要被同步的代码块if else代码写在了synchronized中，只有当一个线程执行完毕之后另一个线程才能继续执行
                 */
                /
                if (ticket > 0) {
                    System.out.println(Thread.currentThread().getName() + ":卖票，票号为：" + ticket);
                    ticket--;
                } else {
                    break;
                }
            }
        }
    }
}

public class WindowTest1 {
    public static void main(String[] args) {
        Window1 w1 = new Window1();
        //三个线程共用一个Window1对象，Window1对象中只new了一个Object，多个线程共用一把锁：obj
        Thread t1 = new Thread(w1);
        Thread t2 = new Thread(w1);
        Thread t3 = new Thread(w1);

        t1.setName("窗口1 ");
        t2.setName("窗口2 ");
        t3.setName("窗口3 ");

        t1.start();
        t2.start();
        t3.start();


    }
}

【例2】使用同步代码块解决继承Thread类方式的线程安全问题
【注意】以下代码也不可以不new一个Object对象，然后将synchronized (obj) 改为synchronized (this)，因为这里的t1,t2,t3都是Window的对象，不能确定this指的到底是哪一个。
【改进】以下代码也可以不new一个Object对象，然后将synchronized (obj) 改为synchronized (Window.class)即可。

/**
 * 例：创建三个窗口卖票，总票数为100张，使用Thread类的方式
 */
class Window extends Thread {

    private static int ticket = 100;//此处用static的原因：
    //如果不用static，那么new了三个对象，每个对象都有100张票，这显然不符合题意
    //当将ticket定义为static之后，不管new了多少个对象，这些对象都公用一个ticket，即共用100张票
    private static Object obj = new Object();//此处用static的原因：
    //使三个对象共用一个obj，来保证三个线程共用一个锁

    @Override
    public void run() {
        while (true) {
            synchronized (obj) {//三个线程分别用三个Window对象，每个Window对象中又有各自的锁：obj，所以在此处，三个线程不共用一个锁
                                //所以要将obj定义为static，来让三个线程共用一个锁
                if (ticket > 0) {
                    System.out.println(getName() + ":卖票，票号为：" + ticket);
                    ticket--;
                } else {
                    break;
                }
            }
        }
    }
}

public class WindowTest {
    public static void main(String[] args) {
        Window t1 = new Window();//三个线程分别用三个Window对象，每个Window对象中又有各自的锁：obj，所以在此处，三个线程不共用一个锁
                                ////所以要将obj定义为static，来让三个线程共用一个锁
        Window t2 = new Window();
        Window t3 = new Window();

        t1.setName("窗口1");
        t2.setName("窗口2");
        t3.setName("窗口3");

        t1.start();
        t2.start();
        t3.start();

    }
}

4.2.2方式二：同步方法

如果操作共享数据的代码完整的声明在一个方法中，我们不妨将此方法声明为同步的。

【例1】使用同步方法实现Runnable接口的线程安全问题

/**
 * 使用同步方法实现Runnable接口的线程安全问题
 */

class Window3 implements Runnable {

    private int ticket = 100;

    @Override
    public void run() {

        while (true) {
            show();
        }
    }

    /**
     * 自定义同步方法show()
     */
    private synchronized void show(){//这里默认的同步监视器：this

        if (ticket > 0) {
            System.out.println(Thread.currentThread().getName() + ":卖票，票号为：" + ticket);
            ticket--;
        }
    }
}

public class WindowTest3 {
    public static void main(String[] args) {
        Window3 w1 = new Window3();

        Thread t1 = new Thread(w1);
        Thread t2 = new Thread(w1);
        Thread t3 = new Thread(w1);

        t1.setName("窗口1 ");
        t2.setName("窗口2 ");
        t3.setName("窗口3 ");

        t1.start();
        t2.start();
        t3.start();


    }
}

【例2】使用同步方法处理继承Thread类的方式中的线程安全问题

/**
 * 使用同步方法处理继承Thread类的方式中的线程安全问题
 */
class Window4 extends Thread {

    private static int ticket = 100;//此处用static的原因：
    //如果不用static，那么new了三个对象，每个对象都有100张票，这显然不符合题意
    //当将ticket定义为static之后，不管new了多少个对象，这些对象都公用一个ticket，即共用100张票

    @Override
    public void run() {
        while (true) {
             show();
        }
    }
    /**
     * 自定义同步方法show()
     */
    public static synchronized void show(){//此处用static的原因：因为在静态方法中不能用this，所以默认的也不是使用this，
                                          //此处的同步监视器默认为：Window4.class
        
        //  public synchronized void show(){//这里默认的同步监视器也是this，但是三个线程分别使用三个对象，这里的this不能确定是t1,t2还是t3
        //所以此种解决方法是错误的
        if (ticket > 0) {
            //此处如果写作：System.out.println(getName() + ":卖票，票号为：" + ticket);则会报错
            //因为getName() 不是静态方法，而show()是静态方法，静态方法不能调用非静态方法
            //所以加上Thread.currentThread().使得getName()方法是由对象调用的即可
            System.out.println(Thread.currentThread().getName() + ":卖票，票号为：" + ticket);
            ticket--;
        }
    }
}

public class WindowTest4 {
    public static void main(String[] args) {
        Window4 t1 = new Window4();
        Window4 t2 = new Window4();
        Window4 t3 = new Window4();

        t1.setName("窗口1");
        t2.setName("窗口2");
        t3.setName("窗口3");

        t1.start();
        t2.start();
        t3.start();

    }
}

过关于同步方法的总结：

  1. 同步方法仍然涉及到同步监视器，只是不需要我们显示声明。
  2. 非静态的同步方法，同步监视器是：this
    静态的同步方法，同步监视器是：当前类本身

4.2.3同步方式的优缺点

优点：

  • 解决了线程的安全性问题

局限性：

  • 操作同步代码时，只能有一个线程参与，其它线程等待。相当于时一个单线程的过程，效率低

4.3 线程的死锁问题

  • 死锁：
    不同的线程分别占用对方需要的同步资源不放弃，都在等待对方放弃自己需要的同步资源，就形成了线程的死锁
    出现死锁后，不会出现异常，不会出现提示，只是所有的线程都处于阻塞状态，无法继续
  • 解决方法：
    专门的算法、原则
    尽量减少同步资源的定义
    尽量避免嵌套同步

【例】演示线程的死锁问题

/**
 * 演示线程的死锁问题
 */
public class ThreadTest2 {
    public static void main(String[] args) {
        final StringBuffer s1 = new StringBuffer();
        final StringBuffer s2 = new StringBuffer();
        new Thread() {
            public void run() {
                synchronized (s1) {
                    s2.append("A");
                    synchronized (s2) {
                        s2.append("B");
                        System.out.print(s1);
                        System.out.print(s2);
                    }
                }
            }
        }.start();
        new Thread() {
            public void run() {
                synchronized (s2) {
                    s2.append("C");
                    synchronized (s1) {
                        s1.append("D");
                        System.out.print(s2);
                        System.out.print(s1);
                    }
                }
            }
        }.start();
    }
}

4.4解决线程安全问题的方式三：Lock（锁）

  • 从JDK 5.0开始，Java提供了更强大的线程同步机制——通过显式定义同步锁对象来实现同步。同步锁使用Lock对象充当。
  • java.util.concurrent.locks.Lock接口是控制多个线程对共享资源进行访问的工具。锁提供了对共享资源的独占访问，每次只能有一个线程对Lock对象加锁，线程开始访问共享资源之前应先获得Lock对象。
  • ReentrantLock 类实现了 Lock ，它拥有与 synchronized 相同的并发性和内存语义，在实现线程安全的控制中，比较常用的是ReentrantLock，可以显式加锁、释放锁。

【例】解决线程安全问题的方式三：Lock锁

import java.util.concurrent.locks.ReentrantLock;

/**
 * 解决线程安全问题的方式三：Lock锁--------JDK5.0新增
 */
class Window5 implements Runnable {
    private int ticket = 100;
    //1.实例化ReentrantLock
    private ReentrantLock lock = new ReentrantLock(true);//fair默认值为false，设置为true后，下一个进程必须在上一个进程结束后才能执行
                                                              //设置为false后，则进程抢占资源

    @Override
    public void run() {
        while (true) {

            try{
                //2.调用实例化对象的lock()方法
                lock.lock();

                if (ticket > 0) {
                    System.out.println(Thread.currentThread().getName() + ":售票，票号为：" + ticket);
                    ticket--;
                } else {
                    break;
                }
            }finally {
                //调用实例化对象的unlock()方法
                lock.unlock();

            }

        }
    }
}

public class LockTest4 {
    public static void main(String[] args) {
        Window5 w5 = new Window5();

        Thread t1 = new Thread(w5);
        Thread t2 = new Thread(w5);
        Thread t3 = new Thread(w5);

        t1.setName("窗口1");
        t2.setName("窗口2");
        t3.setName("窗口3");

        t1.start();
        t2.start();
        t3.start();

    }


}

【运行结果】
在这里插入图片描述

4.5synchronized 与 Lock 的对比

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

【练习】

/**
 * 银行有一个账户。
 * 有两个储户分别向同一个账户存3000元,每次存1000,存3次。每次存完打印账户余额。
 * <p>
 * 分析：
 * 1. 是否是多线程问题？  是，两个储户线程
 * 2. 是否有共享数据？  有，账户（或账户余额）
 * 3. 是否有线程安全问题？  有（因为有共享数据）
 * 4. 需要考虑如何解决线程安全问题？  同步机制：有三种方式
 */

class Account {
    private double balance;//余额

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

    //存钱
    public synchronized void deposit(double amt) {//此处可以不加static的原因：
    											  //此处共用一个对象acct，所以默认的this就是acct
        if (amt > 0) {
            balance += amt;

            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println(Thread.currentThread().getName()+"存钱成功，余额为：" + balance);
        }
    }
}

//例如，用继承Thread类的方式
class Customer extends Thread {

    private Account acct;

    public Customer(Account acct) {
        this.acct = acct;
    }

    @Override
    public void run() {
        for (int i = 0; i < 3; i++) {
            acct.deposit(1000);
        }
    }
}


public class AccountTest {

    public static void main(String[] args) {
        Account acct = new Account(0);
        Customer c1 = new Customer(acct);
        Customer c2 = new Customer(acct);

        c1.setName("甲");
        c2.setName("乙");

        c1.start();
        c2.start();
    }
}

5 线程的通信

【例】使用两个线程印 打印 1-100 。线程1, 线程2 交替打印

/**
 * 线程通信的例子：使用两个线程打印 1-100。线程1，线程2 交替打印
 * 涉及到三个方法：
 * wait()
 * notify()
 * notifyAll()
 */

class Number implements Runnable {
    private int number = 1;

    @Override
    public void run() {

        while (true) {

            synchronized (this) {

                notify();//唤醒线程

                if (number <= 100) {
                    try {
                        Thread.sleep(10);//sleep()使得线程进入阻塞状态，但不会释放锁
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                    System.out.println(Thread.currentThread().getName() + ":" + number);
                    number++;

                    try {
                        //使得调用如下wait()方法的线程进入阻塞状态
                        wait();//waut()使线程进入阻塞状态并且释放当前线程的锁
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                } else {
                    break;
                }
            }
        }
    }
}

public class Communication {
    public static void main(String[] args) {
        Number number = new Number();
        Thread t1 = new Thread(number);
        Thread t2 = new Thread(number);

        t1.setName("线程1");
        t2.setName("线程2");

        t1.start();
        t2.start();
    }
}

5.1 wait() 方法和notify()/notifyAll() 方法

  • wait()：令当前线程挂起并放弃CPU、同步资源并等待，使别的线程可访问并修改共享资源，而当
    前线程排队等候其他线程调用notify()或notifyAll()方法唤醒，唤醒后等待重新获得对监视器的所有
    权后才能继续执行。
  • notify()：唤醒正在排队等待同步资源的线程中优先级最高者结束等待
  • notifyAll ()：唤醒正在排队等待资源的所有线程结束等待.

【注意】

  • wait()，notify()，notifyAll ()这三个方法只有在synchronized(同步)方法或synchronized(同步)代码块中才能使用
  • wait()，notify()，notifyAll ()这三个方法的调用者必须是synchronized(同步)代码块或synchronized(同步)方法中的同步监视器，否则会报java.lang.IllegalMonitorStateException异常。
  • 因为 wait()，notify()，notifyAll () 这三个方法必须有锁对象调用，而任意对象都可以作为synchronized的同步锁，因此这三个方法只能在Object类中声明。

5.12 sleep() 和 wait() 方法的异同：

  1. 相同点： 一旦执行方法，都可以使得当前的线程进入阻塞状态
  2. 不同点：
    1）两个方法声明位置不同：Thread类中声明sleep()，Object类中声明wait()
    2）调用的要求不同：sleep()方法可以在任何需要的场景下调用。wait()必须使用在同步代码块或同步方法中
    3）是否释放同步监视器：如果两个方法都使用在同步代码块或同步方法中，sleep()不会释放锁，wait()会释放锁。

【例】生产者、消费者问题

/**
 * 线程通信的应用：经典例题：生产者/消费者问题
 * 生产者(Productor)将产品交给店员(Clerk)，而消费者(Customer)从店员处取走产品，店员一次只能持有固定数量的产品(比如:20），
 * 如果生产者试图生产更多的产品，店员会叫生产者停一下，如果店中有空位放产品了再通知生产者继续生产；如果店中没有产品了，
 * 店员会告诉消费者等一下，如果店中有产品了再通知消费者来取走产品。
 * 分析：
 * 1.是否是多线程问题？  是，生产者线程，消费者线程
 * 2.是否有共享数据？  是，店员（或产品）
 * 3.如何解决线程安全问题？  同步机制，三种方法
 * 4.是否涉及到线程的通信？  是
 */

class Clerk {//店员

    private int productCount = 0;

    //生产产品
    public synchronized void produceProsuct() {
        if (productCount < 20) {
            productCount++;
            System.out.println(Thread.currentThread().getName() + "：开始生产第" + productCount + "个产品");

            notify();
        } else {
            //等待
            try {
                wait();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }

    }

    //消费产品
    public synchronized void consumeProsuct() {
        if (productCount > 0) {
            System.out.println(Thread.currentThread().getName() + "：开始消费第" + productCount + "个产品");
            productCount--;

            notify();
        } else {
            //等待
            try {
                wait();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }
}

class Producer extends Thread {//生产者

    private Clerk clerk;

    public Producer(Clerk clerk) {
        this.clerk = clerk;
    }

    @Override
    public void run() {
        System.out.println(Thread.currentThread().getName() + "：开始生产产品。。。。。。");

        while (true) {
            try {
                Thread.sleep(10);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            clerk.produceProsuct();
        }

    }
}

class Consumer extends Thread {//消费者

    private Clerk clerk;

    public Consumer(Clerk clerk) {
        this.clerk = clerk;
    }

    @Override
    public void run() {
        System.out.println(Thread.currentThread().getName() + "：开始消费产品。。。。。。");

        while (true) {
            try {
                Thread.sleep(20);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            clerk.consumeProsuct();
        }

    }
}

public class ProductTest {
    public static void main(String[] args) {
        Clerk clerk = new Clerk();

        Producer p1 = new Producer(clerk);
        p1.setName("生产者1");
        Consumer c1 = new Consumer(clerk);
        c1.setName("消费者1");
        Consumer c2 = new Consumer(clerk);
        c2.setName("消费者2");
        
        p1.start();
        c1.start();
        c2.start();

    }
}

6 JDK5.0新增创建线程的方式

6.1新增方式一：实现Callable接口

步骤：

  1. 创建一个实现Callable接口的实现类
  2. 实现call()方法，将线程要执行的操作写在call()方法中
  3. 创建Callable接口实现类的对象
  4. 将此Callable接口实现类的对象作为参数传递到FutureTask构造器中，创建FutureTask的对象
  5. 将FutureTask的对象作为参数传递到Thread类的构造器中，创建Thread对象，并调用start()
  6. 获取Callable中call()方法的返回值（如果不需要返回值，则可以省略该步骤并将call()方法的返回值写为null）

与使用Runnable相比， Callable功能更强大些

  • 重写的call()方法，可以有返回值，而重写的run()方法没有返回值
  • 方法可以抛出异常,而run()方法不能抛出异常，只能try-catch(被重写的父类没有抛出异常，所以子类也不能抛出异常)
  • 支持泛型的返回值
  • 需要借助FutureTask类，比如获取返回结果

Future接口:

  • 可以对具体Runnable、Callable任务的执行结果进行取消、查询是否完成、获取结果等
  • FutrueTask是Futrue接口的唯一的实现类
  • FutureTask 同时实现了Runnable, Future接口。它既可以作为Runnable被线程执行，又可以作为Future得到Callable的返回值

【例】

/**
 * 创建线程的方式三：实现Callable接口。-----JDK 5.0新增
 */
//1.创建一个实现Callable接口的实现类
class NumThread implements Callable{
    //2.实现call()方法，将此线程要执行的操作写在call()方法中
    @Override
    public Object call() throws Exception {
        int sum=0;
        for (int i = 1; i <100 ; i++) {
            if (i%2==0){
                System.out.println(i);
                sum+=i;
            }

        }
        return sum;
    }
}

public class ThreadNew {
    public static void main(String[] args) {
        //3.创建Callable接口实现类的对象
        NumThread numThread=new NumThread();
        //4.将此Callable接口实现类的对象作为参数传递到FutureTask构造器中，创建FutureTask的对象
        FutureTask futureTask = new FutureTask(numThread);
        //5.将FutureTask的对象作为参数传递到Thread类的构造器中，创建Thread对象，并调用start()
        new Thread(futureTask).start();//启动线程

        try {
            //6.获取Callable中call()方法的返回值（如果不需要返回值，则可以省略该步骤并将call()方法的返回值写为null）
            //get()返回值即为FutureTask构造器参数Callable实现类重写的call()方法的返回值
            Object sum = futureTask.get();//快捷键：futureTask.get()+alt+enter
            System.out.println("总和为："+sum);//快捷键：sum+sout
        } catch (InterruptedException e) {
            e.printStackTrace();
        } catch (ExecutionException e) {
            e.printStackTrace();
        }
    }
}

6.2新增方式二：使用线程池

步骤：

  1. 提供指定线程数量的线程池
  2. 执行指定的线程操作。需要提供实现Runnable就扣或Callable接口实现类的对象
  3. 关闭线程池
  • 背景：经常创建和销毁、使用量特别大的资源，比如并发情况下的线程，对性能影响很大。
  • 思路：提前创建好多个线程，放入线程池中，使用时直接获取，使用完放回池中。可以避免频繁创建销毁、实现重复利用。类似生活中的公共交通工具。
  • 好处：
    • 提高响应速度（减少了创建新线程的时间）
    • 降低资源消耗（重复利用线程池中线程，不需要每次都创建）
    • 便于线程管理

【例】

/**
 * 创建线程的方式四：使用线程池
 */

class NumberThread implements  Runnable{

    @Override
    public void run() {
        for (int i = 0; i <=100 ; i++) {
            if (i%2==0){
                System.out.println(Thread.currentThread().getName()+":"+i);
            }
        }
    }
}

class NumberThread1 implements  Runnable{

    @Override
    public void run() {
        for (int i = 0; i <=100 ; i++)
            if (i%2!=0){
                System.out.println(Thread.currentThread().getName()+":"+i);
            }
        }
    }

public class ThreadPool {
    public static void main(String[] args) {
        //1. 提供指定线程数量的线程池
        ExecutorService service= Executors.newFixedThreadPool(10);
        ThreadPoolExecutor serivel= (ThreadPoolExecutor) service;
        //设置线程池的属性
        serivel.setCorePoolSize(15);

        //2. 执行指定的线程操作。需要提供实现Runnable就扣或Callable接口实现类的对象
        service.execute(new NumberThread());//适合用于Runnable
        service.execute(new NumberThread1());
       // service.submit(Callable callable);//适合用于Callable
        //3. 关闭线程池
        service.shutdown();

    }
}

猜你喜欢

转载自blog.csdn.net/qq_42145862/article/details/89160425
今日推荐
《美国对全球网络空间安全与发展的威胁和破坏》报告发布
火速冲上 GitHub 热榜 —— 开源编程语言、框架哪有这么可爱？
北京人形机器人创新中心发布全球首个纯电驱拟人奔跑的全尺寸人形机器人“天工”
LFOSSA 源来如此公开课 | 掌握云原生未来：CNCF 认证全面攻略与备考秘籍
周排行
让自己的头脑极度开放
CentOS 6.5(x64) 和Redhat6.5操作系误删libc
高可用注册中心
【日记】12.28/【题解】AtCoder AGC041
XML（5）_XML 约束_DTD
Java集合Map（四）
树梅派安装桌面环境教程
pipenv 的 使用和安装
小程序白屏问题和内存研究
C语言简单选择排序
每日归档
更多
2024-05-02(0)
2024-05-01(4)
2024-04-30(1)
2024-04-29(40)
2024-04-28(0)
2024-04-27(56)
2024-04-26(39)
2024-04-25(22)
2024-04-24(36)
2024-04-23(26)

代码天地 © 2018 codetd.com

境外服务器   最新电视剧2022