备案控制台
探索云世界
开发者社区 开发与运维 文章 正文

Java基础“多线程”-你想知道的都在这里

2018-07-08 825
版权
版权声明：
本文内容由阿里云实名注册用户自发贡献，版权归原作者所有，阿里云开发者社区不拥有其著作权，亦不承担相应法律责任。具体规则请查看《 阿里云开发者社区用户服务协议》和 《阿里云开发者社区知识产权保护指引》。如果您发现本社区中有涉嫌抄袭的内容，填写 侵权投诉表单进行举报，一经查实，本社区将立刻删除涉嫌侵权内容。
简介： Java 给多线程编程提供了内置的支持。 一条线程指的是进程中一个单一顺序的控制流，一个进程中可以并发多个线程，每条线程并行执行不同的任务。多线程是多任务的一种特别的形式，但多线程使用了更小的资源开销。

Java 给多线程编程提供了内置的支持。 一条线程指的是进程中一个单一顺序的控制流，一个进程中可以并发多个线程，每条线程并行执行不同的任务。

多线程是多任务的一种特别的形式，但多线程使用了更小的资源开销。

这里定义和线程相关的另一个术语 - 进程：一个进程包括由操作系统分配的内存空间，包含一个或多个线程。一个线程不能独立的存在，它必须是进程的一部分。一个进程一直运行，直到所有的非守护线程都结束运行后才能结束。

多线程能满足程序员编写高效率的程序来达到充分利用 CPU 的目的。

进程和线程

进程：是一个正在执行中的程序。每一个进程执行都有一个执行顺序。该顺序是一个执行路径，或者叫一个控制单元。

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

一个进程中至少有一个线程。

Java VM 启动的时候会有一个进程java.exe.

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

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

创建线程的第一种方式-继承Thread类

步骤：

  1. 定义类继承Thread。

  2. 复写Thread类中的run方法。

    目的：将自定义代码存储在run方法。让线程运行。

  3. 调用线程的start方法，

    该方法两个作用：启动线程，调用run方法。

public class ThreadDemo {
    public static void main(String[] args) {
        Demo d = new Demo();//创建好一个线程。
        d.start();//开启线程并执行该线程的run方法。

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

class Demo extends Thread {
    @Override
    public void run() {
        for (int i = 0; i < 60; i++) {
            System.out.println("demo run----" + i);
        }
    }
}
img_ca2cc95067e611ba46d60f39527e7d6d.png
threaddemo.png

发现运行结果每一次都不同。
因为多个线程都获取cpu的执行权。cpu执行到谁，谁就运行。
明确一点，在某一个时刻，只能有一个程序在运行。(多核除外)
cpu在做着快速的切换，以达到看上去是同时运行的效果。
我们可以形象把多线程的运行行为在互相抢夺cpu的执行权。

这就是多线程的一个特性：随机性。谁抢到谁执行，至于执行多长，cpu说的算。

为什么要覆盖run方法呢？

Thread类用于描述线程。该类就定义了一个功能，用于存储线程要运行的代码。该存储功能就是run方法。也就是说Thread类中的run方法，用于存储线程要运行的代码。

线程的运行状态

img_29d70b8a7431ed8c495c9afe2d035dc7.png
线程状态图.png

练习：创建两个线程，和主线程交替运行

class Test extends Thread {
    Test(String name) {
        super(name);
    }

    public void run() {
        for (int x = 0; x < 60; x++) {
            System.out.println((Thread.currentThread() == this) + "..." + this.getName() + " run..." + x);
        }
    }

}


public class ThreadTest {
    public static void main(String[] args) {
        Test t1 = new Test("one---");
        Test t2 = new Test("two+++");
        t1.start();
        t2.start();

        for (int x = 0; x < 60; x++) {
            System.out.println("main....." + x);
        }
    }
}
img_3159b9ec01bd1b20afe974012a5a60f7.png
线程交替运行.png

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

  • static Thread currentThread():获取当前线程对象。
  • getName(): 获取线程名称。
  • 设置线程名称：setName或者构造函数。

创建线程的第二种方式-实现Runnable接口

/**
 * 需求：简单的卖票程序。
 * 多个窗口同时买票。
 */
public class TicketDemo {

    public static void main(String[] args){
        Ticket t = new Ticket();

        Thread t1 = new Thread(t);//窗口1
        Thread t2 = new Thread(t);//窗口2
        Thread t3 = new Thread(t);//窗口3
        Thread t4 = new Thread(t);//窗口4

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

}

class Ticket implements Runnable {

    private int ticket = 500;

    @Override
    public void run() {
        while (ticket > 0) {
            System.out.println(Thread.currentThread().getName() + "----sale:" + ticket--);
        }
    }
}

步骤：

  1. 定义类实现Runnable接口

  2. 覆盖Runnable接口中的run方法。

    将线程要运行的代码存放在该run方法中。

  3. 通过Thread类建立线程对象。

  4. 将Runnable接口的子类对象作为实际参数传递给Thread类的构造函数。

    为什么要将Runnable接口的子类对象传递给Thread的构造函数。
    因为，自定义的run方法所属的对象是Runnable接口的子类对象。
    所以要让线程去指定指定对象的run方法。就必须明确该run方法所属对象。

  5. 调用Thread类的start方法开启线程并调用Runnable接口子类的run方法。

实现方式和继承方式有什么区别呢？

实现方式好处：避免了单继承的局限性。
在定义线程时，建立使用实现方式。

两种方式区别：
继承Thread:线程代码存放Thread子类run方法中。
实现Runnable，线程代码存在接口的子类的run方法。

多线程的安全问题

上面的买票程序，加入线程等待

try{Thread.sleep(10);}catch(Exception e){}
img_2d47a048411014c7b5c65745022a1341.png
线程安全异常.png

可能会出现0，-1，-2号票，多线程的运行出现了安全问题。

问题的原因：

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

解决办法：
对多条操作共享数据的语句，只能让一个线程都执行完。在执行过程中，其他线程不可以参与执行。

多线程同步代码块

Java对于多线程的安全问题提供了专业的解决方式。

就是同步代码块。

synchronized(对象)
{
    需要被同步的代码
}

对象如同锁。持有锁的线程可以在同步中执行。
没有持有锁的线程即使获取cpu的执行权，也进不去，因为没有获取锁。

上面的买票问题加入同步代码块之后：

/**
 * 需求：简单的卖票程序。
 * 多个窗口同时买票。
 */
public class TicketDemo {

    public static void main(String[] args){
        Ticket t = new Ticket();

        Thread t1 = new Thread(t);//窗口1
        Thread t2 = new Thread(t);//窗口2
        Thread t3 = new Thread(t);//窗口3
        Thread t4 = new Thread(t);//窗口4

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

}

class Ticket implements Runnable {

    private int ticket = 500;
    Object obj = new Object();

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

            synchronized (obj){

                if (ticket>0){
//                    try {
//                        Thread.sleep(10);
//                    } catch (InterruptedException e) {
//                        e.printStackTrace();
//                    }
                    System.out.println(Thread.currentThread().getName() + "----sale:" + ticket--);
                }

            }

        }
    }
}
img_49989592cbfb5518941e4d102f4f778b.png
线程同步代码块.png

同步的前提：

  1. 必须要有两个或者两个以上的线程。
  2. 必须是多个线程使用同一个锁。

必须保证同步中只能有一个线程在运行。

好处：解决了多线程的安全问题。

弊端：多个线程需要判断锁，较为消耗资源，

同步函数的锁是this

函数需要被对象调用。那么函数都有一个所属对象引用。就是this。
所以同步函数使用的锁是this。

通过该程序进行验证。

使用两个线程来买票。
一个线程在同步代码块中。
一个线程在同步函数中。
都在执行买票动作。

class Ticket implements Runnable
{
    private  int tick = 100;
    Object obj = new Object();
    boolean flag = true;
    public  void run()
    {
        if(flag)
        {
            while(true)
            {
                synchronized(this)
                {
                    if(tick>0)
                    {
                        try{Thread.sleep(10);}catch(Exception e){}
                        System.out.println(Thread.currentThread().getName()+"....code : "+ tick--);
                    }
                }
            }
        }
        else
            while(true)
                show();
    }
    public synchronized void show()//this
    {
        if(tick>0)
        {
            try{Thread.sleep(10);}catch(Exception e){}
            System.out.println(Thread.currentThread().getName()+"....show.... : "+ tick--);
        }
    }
}


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

        Ticket t = new Ticket();

        Thread t1 = new Thread(t);
        Thread t2 = new Thread(t);
        t1.start();
        try{Thread.sleep(10);}catch(Exception e){}
        t.flag = false;
        t2.start();

    }
}

静态同步函数的锁是class对象

如果同步函数被静态修饰后，使用的锁是什么呢？

通过验证，发现不在是this。因为静态方法中也不可以定义this。

静态进内存是，内存中没有本类对象，但是一定有该类对应的字节码文件对象。
类名.class 该对象的类型是Class

静态的同步方法，使用的锁是该方法所在类的字节码文件对象。 类名.class

class Ticket2 implements Runnable {
    private static int tick = 100;
    //Object obj = new Object();
    boolean flag = true;

    public void run() {
        if (flag) {
            while (true) {
                synchronized (Ticket.class) {
                    if (tick > 0) {
                        try {
                            Thread.sleep(10);
                        } catch (Exception e) {
                        }
                        System.out.println(Thread.currentThread().getName() + "....code : " + tick--);
                    }
                }
            }
        } else
            while (true)
                show();
    }

    public static synchronized void show() {
        if (tick > 0) {
            try {
                Thread.sleep(10);
            } catch (Exception e) {
            }
            System.out.println(Thread.currentThread().getName() + "....show.... : " + tick--);
        }
    }
}


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

        Ticket2 t = new Ticket2();

        Thread t1 = new Thread(t);
        Thread t2 = new Thread(t);
        t1.start();
        try {
            Thread.sleep(10);
        } catch (Exception e) {
        }
        t.flag = false;
        t2.start();


    }
}

死锁

同步中使用的锁不一样，就会造成死锁

class Test implements Runnable {
    private boolean flag;

    Test(boolean flag) {
        this.flag = flag;
    }

    public void run() {
        if (flag) {
            while (true) {
                synchronized (MyLock.locka) {
                    System.out.println(Thread.currentThread().getName() + "...if locka ");
                    synchronized (MyLock.lockb) {
                        System.out.println(Thread.currentThread().getName() + "..if lockb");
                    }
                }
            }
        } else {
            while (true) {
                synchronized (MyLock.lockb) {
                    System.out.println(Thread.currentThread().getName() + "..else lockb");
                    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();
    }
}

线程间通信

img_41283d5396328a95bb78636be706e827.png
线程间通信.png

其实就是多个线程在操作同一个资源，
但是操作的动作不同。

class Res {
    private String name;
    private String sex;
    private boolean flag = false;

    public synchronized void set(String name, String sex) {
        if (flag)
            try {
                this.wait();
            } catch (Exception e) {
            }
        this.name = name;

        this.sex = sex;
        flag = true;
        this.notify();
    }

    public synchronized void out() {
        if (!flag)
            try {
                this.wait();
            } catch (Exception e) {
            }
        System.out.println(name + "........" + sex);
        flag = false;
        this.notify();
    }
}

class Input implements Runnable {
    private Res r;

    Input(Res r) {
        this.r = r;
    }

    public void run() {
        int x = 0;
        while (true) {
            if (x == 0)
                r.set("mike", "man");
            else
                r.set("丽丽", "女女女女女");
            x = (x + 1) % 2;
        }
    }
}

class Output implements Runnable {
    private Res r;

    Output(Res r) {
        this.r = r;
    }

    public void run() {
        while (true) {
            r.out();
        }
    }
}


class InputOutputDemo2 {
    public static void main(String[] args) {
        Res r = new Res();

        new Thread(new Input(r)).start();
        new Thread(new Output(r)).start();
        
    }
}

等待唤醒机制

wait:
notify();
notifyAll();

都使用在同步中，因为要对持有监视器(锁)的线程操作。
所以要使用在同步中，因为只有同步才具有锁。

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

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

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

思考1:wait(),notify(),notifyAll(),用来操作线程为什么定义在了Object类中?

  1. 这些方法存在与同步中。
  2. 使用这些方法时必须要标识所属的同步的锁。
  3. 锁可以是任意对象，所以任意对象调用的方法一定定义Object类中。

思考2:wait(),sleep()有什么区别?

wait():释放cpu执行权，释放锁。

sleep():释放cpu执行权，不释放锁

生产者消费者问题

方法一：

class ProducerConsumerDemo {
    public static void main(String[] args) {
        Resource r = new Resource();

        Producer pro = new Producer(r);
        Consumer con = new Consumer(r);

        Thread t1 = new Thread(pro);
        Thread t2 = new Thread(pro);
        Thread t3 = new Thread(con);
        Thread t4 = new Thread(con);

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

    }
}

class Resource {
    private String name;
    private int count = 1;
    private boolean flag = false;

    //  t1    t2
    public synchronized void set(String name) {
        while (flag)
            try {
                this.wait();
            } catch (Exception e) {
            }//t1(放弃资格)  t2(获取资格)
        this.name = name + "--" + count++;

        System.out.println(Thread.currentThread().getName() + "...生产者.." + this.name);
        flag = true;
        this.notifyAll();
    }


    //  t3   t4  
    public synchronized void out() {
        while (!flag)
            try {
                wait();
            } catch (Exception e) {
            }//t3(放弃资格) t4(放弃资格)
        System.out.println(Thread.currentThread().getName() + "...消费者........." + this.name);
        flag = false;
        this.notifyAll();
    }
}

class Producer implements Runnable {
    private Resource res;

    Producer(Resource res) {
        this.res = res;
    }

    public void run() {
        while (true) {
            res.set("+商品+");
        }
    }
}

class Consumer implements Runnable {
    private Resource res;

    Consumer(Resource res) {
        this.res = res;
    }

    public void run() {
        while (true) {
            res.out();
        }
    }
}

对于多个生产者和消费者。
为什么要定义while判断标记。
原因：让被唤醒的线程再一次判断标记。

为什么定义notifyAll，
因为需要唤醒对方线程。

方法二：

JDK1.5 中提供了多线程升级解决方案。
将同步Synchronized替换成现实Lock操作。
将Object中的wait，notify notifyAll，替换了Condition对象。
该对象可以Lock锁 进行获取。
该示例中，实现了本方只唤醒对方操作。

Lock:替代了Synchronized
lock
unlock
newCondition()

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

import java.util.concurrent.locks.*;

class ProducerConsumerDemo2 {
    public static void main(String[] args) {
        Resource r = new Resource();

        Producer pro = new Producer(r);
        Consumer con = new Consumer(r);

        Thread t1 = new Thread(pro);
        Thread t2 = new Thread(pro);
        Thread t3 = new Thread(con);
        Thread t4 = new Thread(con);

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

    }
}

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) {
            }
        }
    }
}

停止线程

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

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

  1. 定义循环结束标记

    因为线程运行代码一般都是循环，只要控制了循环即

  2. 使用interrupt(中断)方法。

    该方法是结束线程的冻结状态，使线程回到 运行状态中来。

注:stop方法已经过时不再使用。

线程类的其他方法

  • setPriority(int num)
  • setDaemon(boolean b)
  • join()
  • 自定义线程名称
  • toString()
文章标签：
Java
存储
关键词：
Java线程
Java多线程
Java基础
Java基础多线程
shijiacheng
目录
相关文章
游客uul6wusao3sds
|
11天前
|
安全 算法 Java
深入理解Java并发编程：线程安全与性能优化
【4月更文挑战第11天】 在Java中，高效的并发编程是提升应用性能和响应能力的关键。本文将探讨Java并发的核心概念，包括线程安全、锁机制、线程池以及并发集合等，同时提供实用的编程技巧和最佳实践，帮助开发者在保证线程安全的前提下，优化程序性能。我们将通过分析常见的并发问题，如竞态条件、死锁，以及如何利用现代Java并发工具来避免这些问题，从而构建更加健壮和高效的多线程应用程序。
游客uul6wusao3sds
26 9
桃李春风一杯酒
|
4天前
|
安全 Java
深入理解 Java 多线程和并发工具类
【4月更文挑战第19天】本文探讨了Java多线程和并发工具类在实现高性能应用程序中的关键作用。通过继承`Thread`或实现`Runnable`创建线程，利用`Executors`管理线程池，以及使用`Semaphore`、`CountDownLatch`和`CyclicBarrier`进行线程同步。保证线程安全、实现线程协作和性能调优（如设置线程池大小、避免不必要同步）是重要环节。理解并恰当运用这些工具能提升程序效率和可靠性。
桃李春风一杯酒
10 0
一百减一是零
|
4天前
|
安全 Java
java多线程（一）(火车售票)
java多线程（一）(火车售票)
一百减一是零
21 0
桃李春风一杯酒
|
5天前
|
安全 Java 调度
Java并发编程：深入理解线程与锁
【4月更文挑战第18天】本文探讨了Java中的线程和锁机制，包括线程的创建（通过Thread类、Runnable接口或Callable/Future）及其生命周期。Java提供多种锁机制，如`synchronized`关键字、ReentrantLock和ReadWriteLock，以确保并发访问共享资源的安全。此外，文章还介绍了高级并发工具，如Semaphore（控制并发线程数）、CountDownLatch（线程间等待）和CyclicBarrier（同步多个线程）。掌握这些知识对于编写高效、正确的并发程序至关重要。
桃李春风一杯酒
18 4
天下无贼001
|
5天前
|
安全 Java 程序员
Java中的多线程并发编程实践
【4月更文挑战第18天】在现代软件开发中，为了提高程序性能和响应速度，经常需要利用多线程技术来实现并发执行。本文将深入探讨Java语言中的多线程机制，包括线程的创建、启动、同步以及线程池的使用等关键技术点。我们将通过具体代码实例，分析多线程编程的优势与挑战，并提出一系列优化策略来确保多线程环境下的程序稳定性和性能。
天下无贼001
6 0
游客qf4jmczx4xu2y12121
|
6天前
|
缓存 分布式计算 监控
Java并发编程：深入理解线程池
【4月更文挑战第17天】在Java并发编程中，线程池是一种非常重要的技术，它可以有效地管理和控制线程的执行，提高系统的性能和稳定性。本文将深入探讨Java线程池的工作原理，使用方法以及在实际开发中的应用场景，帮助读者更好地理解和使用Java线程池。
游客qf4jmczx4xu2y12121
10 1
橙子先生
|
6天前
|
存储 安全 Java
Java中的容器，线程安全和线程不安全
Java中的容器，线程安全和线程不安全
橙子先生
13 1
技术混子
|
6天前
|
Java 开发者
Java中多线程并发控制的实现与优化
【4月更文挑战第17天】 在现代软件开发中，多线程编程已成为提升应用性能和响应能力的关键手段。特别是在Java语言中，由于其平台无关性和强大的运行时环境，多线程技术的应用尤为广泛。本文将深入探讨Java多线程的并发控制机制，包括基本的同步方法、死锁问题以及高级并发工具如java.util.concurrent包的使用。通过分析多线程环境下的竞态条件、资源争夺和线程协调问题，我们提出了一系列实现和优化策略，旨在帮助开发者构建更加健壮、高效的多线程应用。
技术混子
6 0
桃李春风一杯酒
|
7天前
|
缓存 监控 Java
Java并发编程：线程池与任务调度
【4月更文挑战第16天】Java并发编程中，线程池和任务调度是核心概念，能提升系统性能和响应速度。线程池通过重用线程减少创建销毁开销，如`ThreadPoolExecutor`和`ScheduledThreadPoolExecutor`。任务调度允许立即或延迟执行任务，具有灵活性。最佳实践包括合理配置线程池大小、避免过度使用线程、及时关闭线程池和处理异常。掌握这些能有效管理并发任务，避免性能瓶颈。
桃李春风一杯酒
6 0
我不是游客20240119
|
7天前
|
设计模式 运维 安全
深入理解Java并发编程：线程安全与性能优化
【4月更文挑战第15天】在Java开发中，多线程编程是提升应用程序性能和响应能力的关键手段。然而，它伴随着诸多挑战，尤其是在保证线程安全的同时如何避免性能瓶颈。本文将探讨Java并发编程的核心概念，包括同步机制、锁优化、线程池使用以及并发集合等，旨在为开发者提供实用的线程安全策略和性能优化技巧。通过实例分析和最佳实践的分享，我们的目标是帮助读者构建既高效又可靠的多线程应用。
我不是游客20240119
55 4

热门文章

最新文章

  • 1
    Java中的多线程编程：概念、实现与性能优化
  • 2
    java智慧城管源码 AI视频智能分析 可直接上项目
  • 3
    Java 学习路线：基础知识、数据类型、条件语句、函数、循环、异常处理、数据结构、面向对象编程、包、文件和 API
  • 4
    基于 java + Springboot + vue +mysql 大学生实习管理系统（含源码）
  • 5
    使用Java代码打印log日志
  • 6
    Java数据结构与算法-java数据结构与算法（二）
  • 7
    【JVM故障问题排查心得】「Java技术体系方向」Java虚拟机内存优化之虚拟机参数调优原理介绍（一）
  • 8
    深入理解Java并发编程：线程安全与性能优化
  • 9
    开发语言详解（python、java、Go(Golong)。。。。）
  • 10
    《理解 WebSocket：Java Web 开发的实时通信技术》
  • 1
    Elasticsearch【问题记录 01】启动服务&停止服务的2类方法【及 java.nio.file.AccessDeniedException: xx/pid 问题解决】（含shell脚本文件）
    22
  • 2
    Java 数组
    13
  • 3
    Java Lambda表达式简介
    9
  • 4
    Java版HIS系统 云HIS系统 云HIS源码 结构简洁、代码规范易阅读
    21
  • 5
    ZooKeeper【基础 03】Java 客户端 Apache Curator 基础 API 使用举例（含源代码）
    21
  • 6
    Java动态转发代理IP的实现方法
    20
  • 7
    基于Java的电影评论系统的设计与实现(源码+lw+部署文档+讲解等)
    19
  • 8
    基于Java的在线日语培训平台的设计与实现(源码+lw+部署文档+讲解等)
    21
  • 9
    基于Java的同城蔬菜配送管理系统的设计与实现(源码+lw+部署文档+讲解等)
    9
  • 10
    基于Java的心理预约咨询管理系统的设计与实现(源码+lw+部署文档+讲解等)
    20

    • 相关课程

    更多
  • Java面试疑难点解析 - Java Web开发
  • Java编程入门
  • Java面向对象编程
  • Java高级编程

    • 相关电子书

    更多
  • Spring Cloud Alibaba - 重新定义 Java Cloud-Native
  • The Reactive Cloud Native Arch
  • JAVA开发手册1.5.0

    • 相关实验场景

    更多
  • 基于ECS搭建Java Web开发环境
  • 使用Aliyun Java Intializr进行项目开发
  • 搭建Java Web开发环境
  • 部署基于Dragonwell的Java运行环境
  • 阿里云平台上进行Java程序的编译与运行
    • 下一篇
    部署LAMP环境（Alibaba Cloud Linux 3）