尚硅谷JAVA知识点总结源码(侵删)

最新推荐文章于 2023-01-14 13:17:55 发布
最新推荐文章于 2023-01-14 13:17:55 发布
阅读量191 收藏
点赞数
分类专栏： 尚硅谷java知识点 文章标签： java 开发语言
原文链接：https://www.bilibili.com/video/BV1Kb411W75N?p=451
版权

JAVA多线程

基础创建线程知识：
线程的生命周期

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-eneSVOgO-1653097281839)(D:\桌面\备忘录\Thread\线程的生命周期.png)]

测试Thread中的常用方法：
  • 1.start()： 启动当前线程：调用当前线程的run()
    1. run(): 通常需要重写Thread类中的此方法，将创建的线程要执行的操作声明在此方法中
    1. currentThread(): 静态方法，返回执行当前代码的线程
    1. getName():获取当前线程的名字
    1. seName()：设置当前线程的名字
    1. yield(): 释放当前CPU的执行权
    1. join(): 在线程a中调用线程b的join(),此时线程a就进入阻塞状态，直到线程b全部执行往后，线程a才结束阻塞状态
  • 8.stop():强制停止当前线程，已经废用
  • 9.sleep(millseconds): 里面的参数是毫秒，指的是阻塞一定毫秒
  • 线程的优先级：
  • MAX_PRIORITAY = 10
  • MIN_PRIORITAY = 1
  • NORM_PRIORITAY = 5 -->默认的优先级
  • 获取当前的：getPriorit()
  • 设置当前的:setPriority()
package Demo01;

/**
 * 测试Thread中的常用方法：
 * 1.start()： 启动当前线程：调用当前线程的run()
 * 2. run(): 通常需要重写Thread类中的此方法，将创建的线程要执行的操作声明在此方法中
 * 3. currentThread(): 静态方法，返回执行当前代码的线程
 * 4. getName():获取当前线程的名字
 * 5. seName()：设置当前线程的名字
 * 6. yield(): 释放当前CPU的执行权
 * 7. join(): 在线程a中调用线程b的join(),此时线程a就进入阻塞状态，直到线程b全部执行往后，线程a才结束阻塞状态
 * 8.stop():强制停止当前线程，已经废用
 * 9.sleep(millseconds): 里面的参数是毫秒，指的是阻塞一定毫秒
 *
 * 线程的优先级：
 * MAX_PRIORITAY = 10
 * MIN_PRIORITAY = 1
 * NORM_PRIORITAY = 5 -->默认的优先级
 * 获取当前的：getPriorit()
 * 设置当前的:setPriority()
 * @author xiahui
 * @description TODO
 * @create 2022--05--1322:44
 */

class TestThread01 extends Thread{
    public TestThread01(String name) {
        super(name);
    }

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

public class TestThreadFunction01 {
    public static void main(String[] args) {
        TestThread01 t1 = new TestThread01("Thread0001");

        t1.start();
        for (int i = 1; i < 100; i++) {
            if (i % 2 != 0) {
                System.out.println("主" + Thread.currentThread().getName() + ":" + i);
            }
            if (i == 20){
                try {
                    t1.join();
                } catch (InterruptedException e) {
                    throw new RuntimeException(e);
                }
            }
        }
    }
}
多线程的创建方式
方式一：继承于Thread类*
    1. 创建一个继承于Thread类的子类
    1. 创建Thread类的run() --> 将此线程执行的操作声明在run()中
    1. 创建Thread类的子类的对象
    1. 通过此对象调用start()
创建多线程的方式二：实现Runnable接口
    1. 创建一个实现了Runnable接口的类
    1. 实现类去实现Runnable中的抽象方法: run()
    1. 创建实现类的此对象
    1. 将此对象作为参数传递到Thread类的构造器中，创建Thread类的对象
    1. 通过Thread调用start();
package Demo01;
/**
 * @author xiahui
 * @description TODO 创建两个分线程，一个线程遍历100以内的奇数，另一个是偶数
 * @create 2022--05--1320:05
 */
class MyThread01 extends Thread{
    @Override
    public void run() {
        for (int i = 1; i < 100; i++) {
            if (i % 2 == 0){
                System.out.println("偶数"+Thread.currentThread().getName()+":"+i);
            }
        }
    }
}
class MyThread02 extends Thread{
    @Override
    public void run() {
        for (int i = 1; i < 100; i++) {
            if (i % 2 != 0){
                System.out.println("奇数"+Thread.currentThread().getName()+":"+i);
            }
        }
    }
}
public class Test01 {
    public static void main(String[] args) {
//        MyThread01 myThread01 = new MyThread01();
//        MyThread02 myThread02 = new MyThread02();
//        myThread01.start();
//        myThread02.start();

        // 匿名子类方法
        new Thread() {
            @Override
            public void run() {
                for (int i = 1; i < 100; i++) {
                    if (i % 2 != 0) {
                        System.out.println("匿名子类方法+奇数" + Thread.currentThread().getName() + ":" + i);
                    }
                }
                ;
            }
        }.start();
    }
}

package Demo01;

/**
 * @description creatThread
 * @author xiahui
 * @create 2022--05--1223:23
 */

/**
 * 多线程的创建，方式一：继承于Thread类
 * 1. 创建一个继承于Thread类的子类
 * 2. 创建Thread类的run() --> 将此线程执行的操作声明在run()中
 * 3. 创建Thread类的子类的对象
 * 5. 通过此对象调用start()
 */
// 例子： 遍历100以内的所有偶数
class MyThread extends Thread{
    // 重写Thread类的run()
    @Override
    public void run() {
        for (int i = 0; i < 100; i++) {
            if (i % 2 == 0){
                System.out.println(i);
            }
        }
    }
}

public class creatThreat01 {
    public static void main(String[] args) {
        // 创建Thread类的子类
        MyThread t1 = new MyThread();
        t1.start();
    }
}
线程安全问题以及解决方案：
方式一

1.问题：卖票的过程中，出现了重票、错票 -->出现了线程的安全问题

  • 2.问题出现的原因： 当某个线程操作车票的过程中，尚未操作完成时，其他线程参与进来，也操作车票。
  • 3.如何解决：当一个线程a在操作ticket时，其他线程不能参与进来，直到线程a操作完成ticket后，其他线程才可以操作ticket，
  • 这种情况即使线程a出现了阻塞，也不能被改变。
  • 说明：1. 操作共享数据的代码，即为需要被同步的代码
    1. 共享数据，多个线程共同操作的变量。比如：ticket就是共享数据
    1. 同步监听器：俗称：锁 任何一个类的对象，都可以充当锁
方式二

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

  • 关于同步方法的总结：

    1. 同步方法仍然涉及到同步监视器，只是不需要我们显示的声明
    1. 非静态的同步方法，同步监视器是this

  • 静态的同步方法，同步监视器是类本身

    1. 同步的方式，解决了线程的安全问题 --> 好处

  • 局限性：操作同步代码时，只有一个线程参与，其他线程等待，相当于单线程

  • 开发中，优先选择：实现Runna接口的方式

    原因: 1. 实现的方式没有类的单继承的局限性

    1. 实现的方式更适合来处理多个继承共享数据的情况

  • 窗口问题使用Runnable()来解决，不需要static

package Demo01;

/**
 * @author xiahui
 * @description TODO 创建三个窗口，一共卖票30张
 * 1.问题：卖票的过程中，出现了重票、错票 -->出现了线程的安全问题
 * 2.问题出现的原因： 当某个线程操作车票的过程中，尚未操作完成时，其他线程参与进来，也操作车票。
 * 3.如何解决：当一个线程a在操作ticket时，其他线程不能参与进来，直到线程a操作完成ticket后，其他线程才可以操作ticket，
 *   这种情况即使线程a出现了阻塞，也不能被改变。
 * 说明：1. 操作共享数据的代码，即为需要被同步的代码
 *      2. 共享数据，多个线程共同操作的变量。比如：ticket就是共享数据
 *      3. 同步监听器：俗称：锁 任何一个类的对象，都可以充当锁
 * 方式二：同步方法
 *  如果操作共享数据的代码完整的声明在一个方法中，我们不妨将此方法声明为同步的
 *
 * 关于同步方法的总结：
 * 1. 同步方法仍然涉及到同步监视器，只是不需要我们显示的声明
 * 2. 非静态的同步方法，同步监视器是this
 *    静态的同步方法，同步监视器是类本身
 * 5. 同步的方式，解决了线程的安全问题 --> 好处
 * 局限性：操作同步代码时，只有一个线程参与，其他线程等待，相当于单线程
 * @create 2022--05--14-10:16
 */
// 使用同步方法处理函数继承Thread类的方式中的线程安全问题
class SailWindow extends Thread{
    private static int ticket = 100;

    @Override
    public void run() {
        while(true){
            show();
        }
    }
    private  static synchronized void show(){ // 同步监视器是：Window.class
        if (ticket > 0){ // 这种方法是错误的 同步监视器t1,t2,t3不行
            System.out.println("窗口"+Thread.currentThread().getName() + ": 卖票号" + ticket);
            ticket--;
        }
    }

    public SailWindow(String name) {
        super(name);
    }
}

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

        SailWindow sw1 = new SailWindow("一");
        SailWindow sw2 = new SailWindow("二");
        SailWindow sw3 = new SailWindow("三");

        sw1.start();
        sw2.start();
        sw3.start();

    }
}

package Demo01;

/**
 * 开发中，优先选择：实现Runna接口的方式
 * 原因: 1. 实现的方式没有类的单继承的局限性
 *       2. 实现的方式更适合来处理多个继承共享数据的情况
 * 窗口问题使用Runnable()来解决，不需要static
 * @author xiahui
 * @description TODO
 * @create 2022--05--1410:44
 */
class SailWindow02 implements Runnable {
    public int ticket = 100;
    Dog dog = new Dog();
    // 类也是一个对象
    // synchronized(Window2.class) // Class clazz = Window2.class
    // synchronized(this)
    // 在继承Thread时，最好要小心不要用this来充当对象
    @Override
    public void run() {
        synchronized (dog) {
            while (ticket > 0) {
                System.out.println("窗口" + Thread.currentThread() + ": 卖票号" + ticket);
                ticket--;
            }
        }
    }
}

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

        SailWindow w = new SailWindow("窗口");

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

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

    }
}

class Dog{}
使用懒汉式设计模式将线程改为安全的：
package Demo02;

/**
 * @author Xiahui
 * @description TODO
 * @-Email- 2050164314@qq.com
 * @create 2022--05--18--15:10
 */

class Bank{
    private Bank(){}
    private static Bank instance = new Bank();

//    public synchronized static Bank getInstance(){
//        // 方式一： 效率稍微差
//        if (instance == null){
//            instance = new Bank();
//        }
//        return instance;
//    }
    // 方式二： 效率稍高，建议使用
    public static Bank getInstance(){
        if (instance == null){
            synchronized (Bank.class){
                if(instance == null){
                    instance = new Bank();
                }
            }
        }
        return instance;
    }
}

public class BankTest01 {
}
死锁的问题

死锁是指在执行并发计算时，一组进程中的每个进程都在等待包括自身在内的其他进程释放资源的一种现象 说明：出现死锁后，不会出现异常，不会出现提示，只是所有的进程都处于阻塞状态，无法继续

避免方法：

  • 专门的算法、原则
  • 尽量减少同步资源的定义
  • 尽量避免嵌套同步
package Demo02;

/**
 * @author Xiahui
 * @description TODO 演示死锁的过程
 * // 这里s1等待s2释放锁，而s2等待s1释放锁，就这样产生了死锁
 *说明：出现死锁后，不会出现异常，不会出现提示，只是所有的进程都处于阻塞状态，无法继续
 * @-Email- 2050164314@qq.com
 * @create 2022--05--18--22:01
 */

public class ThreadDeadLockTest01 {
    public static void main(String[] args) {
        StringBuffer s1 = new StringBuffer();
        StringBuffer s2 = new StringBuffer();

        new Thread(){
            @Override
            public void run() {
                synchronized (s1){
                    s1.append('a');
                    s2.append('1');
                    // 这里加一个sleep()，死锁的概率会增加
                    try {
                        Thread.sleep(100);
                    } catch (InterruptedException e) {
                        throw new RuntimeException(e);
                    }

                    synchronized(s2){
                       s1.append('b');
                       s2.append('2');
                        System.out.println(s1);
                        System.out.println(s2);
                    }
                }
            }
        }.start();

        new Thread(new Runnable() {
            @Override
            public void run() {
                synchronized (s2){
                    s1.append('c');
                    s2.append('3');
                    try {
                        Thread.sleep(100);
                    } catch (InterruptedException e) {
                        throw new RuntimeException(e);
                    }
                    synchronized(s1){
                        s1.append('d');
                        s2.append('4');
                        System.out.println(s1);
                        System.out.println(s2);
                    }
                }
            }
        }).start();
    }
}
方式三：Lock锁

JDK5.0新增方式

import java.util.concurrent.locks.ReentrantLock;

synchronized和lock的用法区别。synchronized：在需要同步的对象中加入此控制，synchronized可以加在方法上，也可以加在特定代码块中，括号中表示需要锁的对象。lock：需要显示指定起始位置和终止位置。一般使用ReentrantLock类做为锁，多个线程中必须要使用一个ReentrantLock类做为对象才能保证锁的生效。且在加锁和解锁处需要通过lock()和unlock()显示指出。所以一般会在finally块中写unlock()以防死锁。

package Demo02;
// 导包
import java.util.concurrent.locks.ReentrantLock;

/**
 * @author Xiahui
 * @description TODO
 * @-Email- 2050164314@qq.com
 * @create 2022--05--18--22:33
 */

class TestLock implements Runnable{

    private int ticket = 100;
    // 创建 ReentrantLock对象
    private ReentrantLock lock = new ReentrantLock();  // 一个是公平True，一个一个来，另一个False是unFair
    @Override
    public void run() {
        while (true){
            try{
                // 调用lock方法，锁住
                lock.lock();
                if (ticket > 0){
                    try {
                        Thread.sleep(100);
                    } catch (InterruptedException e) {
                        throw new RuntimeException(e);
                    }
                    System.out.println(Thread.currentThread().getName()+"售票，票号为"+ticket);
                    ticket--;
                }else {
                    break;
                }
            }finally {
                // 调用unlock,解除锁
                lock.unlock();
            }
        }
    }
}

public class ThreadLockTest01 {
    public static void main(String[] args) {
        TestLock t = new TestLock();

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

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

测试:

package Demo02;
import static java.lang.Thread.sleep;
/**
 * 问题：银行有一个账户
 * 有两个储户分别向同一个账户存3000元，每次存1000元，存三次，每次打印余额
 * 分析：
 * 1.是否有多线程问题？有，两个储户线程
 * 2.是否有共享数据，是，账户余额
 * 3.是否有线程安全问题，有
 * 4.需要考虑如何解决线程安全问题，同步机制，有三种方式。
 * @author Xiahui
 * @description TODO
 * @-Email- 2050164314@qq.com
 * @create 2022--05--18--23:18
 */

class Account{
    private double balance;
    // 存钱
    public Account(double balance){
        this.balance = balance;
    }
    public synchronized void deposit(double amt) {
        if (amt > 0) {
                balance += amt;
                try {
                    sleep(100);
                } catch (InterruptedException e) {
                    throw new RuntimeException(e);
                }
                System.out.println(Thread.currentThread().getName() + "存钱成功,余额为" + balance);
            }
    }
}

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();
    }
}
线程通信例子

一：使用两个线程打印1-100，线程一，二交互打印

package Demo02;
/**
 * @author Xiahui
 * @description TODO 线程通信的例子： 使用两个线程打印1-100，线程一，二交互打印
 * @-Email- 2050164314@qq.com
 * @create 2022--05--19--14:45
 */

class Number implements Runnable{
    private int num = 1;

    //ReentrantLock lock = new ReentrantLock(true);
    @Override
    public void run() {
        while (true) {
            try {
                Thread.sleep(100);
            } catch (InterruptedException e) {
                throw new RuntimeException(e);
            }

            synchronized (this) {
                notify();
                if (num <= 100) {
                    System.out.println(Thread.currentThread().getName() + "number:" + num);
                    num++;
                    try {
                        // 使得调用wait()方法的进程进入阻塞状态，用上面的notify()函数唤醒，调用wait()方法，锁自动解开
                        wait();
                    } catch (InterruptedException e) {
                        throw new RuntimeException(e);
                    }
                }else {
                    break;
                }
            }
        }
    }
}

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

        Number n = new Number();
        Thread t1 = new Thread(n);
        Thread t2 = new Thread(n);

        t1.setName("t1");
        t2.setName("t2");

        t1.start();
        t2.start();
    }
}
sleep()和wait()区别：

区别一：语法使用不同

  1. wait 方法必须配合 synchronized 一起使用，不然在运行时就会抛出 IllegalMonitorStateException 的异常

  2. 而 sleep 可以单独使用，无需配合 synchronized 一起使用。

区别二：所属类不同

  1. wait 方法属于 Object 类的方法，而 sleep 属于 Thread 类的方法

区别三：唤醒方式不同

  1. sleep 方法必须要传递一个超时时间的参数，且过了超时时间之后，线程会自动唤醒。而 wait 方法可以不传递任何参数，不传递任何参数时表示永久休眠，直到另一个线程调用了 notify 或 notifyAll 之后，休眠的线程才能被唤醒。也就是说 sleep 方法具有主动唤醒功能，而不传递任何参数的 wait 方法只能被动的被唤醒。

区别四：释放锁资源不同

  1. sleep 不释放锁，wait释放锁

区别五：线程进入状态不同

  1. 调用 sleep 方法线程会进入 TIMED_WAITING 有时限等待状态，而调用无参数的 wait 方法，线程会进入 WAITING 无时限等待状态

总结

  1. 调用 sleep 方法线程会进入 TIMED_WAITING 有时限等待状态，而调用无参数的 wait 方法，线程会进入 WAITING 无时限等待状态
经典例题：消费者和生产者
package Demo03;

/**
 * @author Xiahui
 * @description TODO 经典例题，生产者，消费者问题
 * @-Email- 2050164314@qq.com
 * @create 2022--05--19--15:32
 */

class Clerk{
    private int productCount = 0;
    public synchronized void produceProduct(){
        if (productCount < 20){
            productCount++;
            System.out.println("开始生产第"+productCount+"个");
            notify();
        }
        else{
            try {
                wait();
            } catch (InterruptedException e) {
                throw new RuntimeException(e);
            }
        }
    }

    public synchronized void consumerProduct() {
        if (productCount > 0){
            try {
                Thread.sleep(3000);
            } catch (InterruptedException e) {
                throw new RuntimeException(e);
            }
            System.out.println("开始购买第"+productCount+"个");
            productCount--;
            notify();
        }
        else{
            try {
                wait();
            } catch (InterruptedException e) {
                throw new RuntimeException(e);
            }
        }
    }
}

class Producer extends Thread {  // 生产者
    private Clerk clerk;

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

    @Override
    public void run() {
        System.out.println(getName() + "开始生产产品....");
        while (true) {
            try {
                Thread.sleep(100);
            } catch (InterruptedException e) {
                throw new RuntimeException(e);
            }
            clerk.produceProduct();
        }
    }
}
class Consumer extends Thread { // 消费者

    private Clerk clerk;

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

    @Override
    public void run() {
        System.out.println(getName() + "开始消费产品....");
        while (true) {
            try {
                Thread.sleep(100);
            } catch (InterruptedException e) {
                throw new RuntimeException(e);
            }
            clerk.consumerProduct();
        }
    }
}
public class ConsumerAndProducer {
    public static void main(String[] args) {

        Clerk c = new Clerk();

        Consumer c1 = new Consumer(c);
        Producer p1 = new Producer(c);
        c1.setName("c1");
        p1.setName("p1");

        c1.start();
        p1.start();
    }
}
创建多线程的方式三：Callable() JDK 5.0
  • 第一步：创建一个实现Callable的实现类
  • 第二步：实现call方法，将此线程需要执行的操作声明在call()中
  • 第三步：创建Callable接口实现的类
  • 第四步：将此Callable接口实现类的对象作为传递到FutureTask的构造器当中，创建FutureTask的对象
  • 第五步：将FutureTask的对象作为参数传递到Thread的类的构造器当中，并start();
  • 第六步(可选)：获取Callable中的返回值
package Demo03;

import java.util.concurrent.Callable;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.FutureTask;

/**
 * @author Xiahui
 * @description TODO 创建多线程的方式三：JDK5.0新增 callable接口
 * @-Email- 2050164314@qq.com
 * @create 2022--05--19--21:35
 */


class NumThread implements Callable{
    @Override
    public Object call() throws Exception {
        int sum = 1;
        for (int i = 1; i < 100; i++) {
            if (i %2 == 0){
                System.out.println(i);
                sum += i;
            }
        }
        return sum;
    }
}

public class ThreadCallable {
    public static void main(String[] args) {
        // 创建一个NumThread对象
        NumThread numThread = new NumThread();
        // 需要创建一个FutureTask
        FutureTask futureTask = new FutureTask(numThread);

        // Future 已经实现了Runnable接口
        new Thread(futureTask).start();
        // get()返回值即为FutureTask构造器参数Callable实现类重写的call()的返回值
        try {
            Object sum = futureTask.get();
            System.out.println("总和为："+sum);
        } catch (InterruptedException e) {
            throw new RuntimeException(e);
        } catch (ExecutionException e) {
            throw new RuntimeException(e);
        }

    }
}
Runnable和Callable区别

  1. Runnable没有返回值；Callable可以返回执行结果，是个泛型，和Future、FutureTask配合可以用来获取异步执行的结果；

  2. Callable接口的call（）方法允许抛出异常；Runnable的run（）方法异常只能在内部消化，不能往上继续抛；

  3. 注：Callalbe接口支持返回执行结果，需要调用FutureTask.get（）得到，此方法会阻塞主进程的继续往下执行，如果不调用不会阻塞。

​

线程的创建方式四：线程池
  1. 线程池的优点:
    重用线程池中的线程,减少因对象创建,销毁所带来的性能开销;
    能有效的控制线程的最大并发数,提高系统资源利用率,同时避免过多的资源竞争,避免堵塞;
    能够多线程进行简单的管理,使线程的使用简单、高效。
  2. 线程池框架Executor
    java中的线程池是通过Executor框架实现的，Executor 框架包括类：Executor，Executors，ExecutorService，ThreadPoolExecutor ，Callable和Future、FutureTask的使用等。
package Demo03;

import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;

/**
 * @author Xiahui 创建线程池
 * @description TODO
 * @-Email- 2050164314@qq.com
 * @create 2022--05--20--14:29
 */

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

public class creatThreadByPool {
    public static void main(String[] args) {
        // 创建线程池
        // 提供指定数量的线程池
        ExecutorService service = Executors.newFixedThreadPool(10);
        // 执行指定的线程的操作，需要提供实现Runnable接口或Callable接口实现类的的对象
        service.execute(new NumThreadTest02());  // 适用于Runnable
//        service.submit(); // 适用于Callable
        service.shutdown();
    }
}

va
package Demo03;

import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;

/**

  • @author Xiahui 创建线程池
  • @description TODO
  • @-Email- 2050164314@qq.com
  • @create 2022–05–20–14:29
    */

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

public class creatThreadByPool {
public static void main(String[] args) {
// 创建线程池
// 提供指定数量的线程池
ExecutorService service = Executors.newFixedThreadPool(10);
// 执行指定的线程的操作，需要提供实现Runnable接口或Callable接口实现类的的对象
service.execute(new NumThreadTest02()); // 适用于Runnable
// service.submit(); // 适用于Callable
service.shutdown();
}
}
xiahui66
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
专栏目录
尚硅谷_Java基础实战_Bank项目_源代码.zip
08-18
尚硅谷_Java基础实战_Bank项目_源代码，循序渐进的完成了BANK小项目，将JAVA的面向对象，很好的应用到实际代码编写中，通过学习这些代码，可以很好地加深对JAVA语言的理解，以及对JAVA面向对象编程的理解，提升自己的能力。
Java尚硅谷学习代码
weixin_52340910的博客
10-05 203
学习java数据结构
分享111个Java源码，总有一款适合您
最新发布
zy0412326的专栏
01-14 1万+
java 源码
尚硅谷Java基础实战-Bank项目教程（附需求、源码）
08-03
《Bank项目》是尚硅谷版权的"Java基础阶段" 代码实战之一。该项目在讲授JavaSE时以讲师引导、学员实战的方式完成。同时，此项目也可作为Java从业人员、Java自学者自测检验的经典项目！
尚硅谷Java8练习Java源码
01-12
内容还有尚硅谷Java8练习Java源码，一系列课程教学源码
尚硅谷SpringCloud视频 + 源码 百度网盘
11-06
根据给定文件的信息，我们可以提炼出以下几个重要的知识点： ### 一、SpringCloud简介与核心组件 #### 1.1 SpringCloud概述 SpringCloud是一套基于Spring Boot实现的微服务云应用开发工具集，它提供了在分布式系统...
尚硅谷_宋红康_Java 5-11各个版本新特性最全总结.pdf
07-08
·自Java语言起源始，循序渐进，知识点剖析细致且每章配备大量随堂练习，让你步步为营，学得透彻、练得明白 ·拒绝晦涩难懂的呆板教学，宋老师语言生动幽默，举例形象生动深入浅出，迅速让你把握问题本质，四两拨千...
某硅谷java9新特性学习完整视频，课件，源码
10-16
根据提供的文件信息，我们可以深入探讨Java 9的一些关键新特性及其对开发人员的影响。尚硅谷作为知名的IT教育机构，提供...总而言之，Java 9带来了一系列重要的更新，这些更新对于Java开发者来说都是不可或缺的知识点。
尚硅谷《全套Java、Android、HTML5前端视频》
04-29
根据提供的信息，我们可以总结出以下相关的IT知识点： ### Java 基础阶段 #### Java基础知识 - **20天横扫Java基础**：这是一门针对初学者的课程，覆盖了Java的基础语法、数据类型、流程控制语句、类与对象的概念...
尚硅谷spring boot资源，带代码。
09-19
### Spring Boot概述与核心知识点详解 #### 一、Spring Boot简介 Spring Boot 是由 Pivotal 团队提供的一款开源框架，旨在简化基于 Spring 的应用开发流程。它通过内置默认配置来减少开发者需要手动配置的工作量，...
尚硅谷 4月份MyBatis视频教程（国内首套：源码级讲授的MyBatis视频）最新更新
11-30
根据提供的文件信息，本次将对MyBatis框架的相关知识点进行深入解析。MyBatis是一款优秀的持久层框架，它支持自定义SQL、存储过程以及高级映射。MyBatis避免了几乎所有的JDBC代码和手动设置参数以及获取结果集，通过...
2017_尚硅谷MyBatis最新视频
04-19
根据提供的文件信息，以下是从标题、描述、标签以及部分内容中提取和扩展的相关知识点： ### 一、MyBatis概述 **MyBatis** 是一款优秀的持久层框架，它支持定制化 SQL、存储过程以及高级映射。MyBatis 免除了几乎...
尚硅谷视频打包地址（包含MySQL高级、JS等最新视频）
03-03
根据提供的信息，我们可以总结出以下相关的IT知识点： ### 1. 尚硅谷视频资源概览 尚硅谷是一家知名的在线教育平台，提供丰富的IT技术视频教程。本次提供的资源涵盖了多个技术领域，包括Java、Android以及前端技术...
尚硅谷视频连接
05-28
根据提供的信息，我们可以总结出以下相关的IT知识点，主要聚焦于Java EE、Android开发以及相关技术栈。 ### Java EE基础知识 #### Java基础阶段 - **Java基础**：尚硅谷提供了全面的Java基础知识教学视频，帮助...
【程序源代码】每日种草-撩课Python智能全套视频
程序源代码
09-24 322
关键字：《我是种草囤货君、每日种草系列》 资源包正文|内容01—【概述】“野火烧不尽，春风吹又生”，最近小编我的种草欲总是挥之不去，不管别人劝阻还是自我放弃，隔几天又会浮上心头。...
史上最牛、最适合自学的尚硅谷《全套Java视频教程》
weixin_30776863的博客
12-14 1236
涵盖：视频教程、在线课堂、最新教程SpringMVC 视频教程 Java基础阶段： 一、20天横扫Java基础（课堂实录） http://pan.baidu.com/s/1kTgIYDT 二、尚硅谷Java基础实战——Bank项目 http://pan.baidu.com/share/link?shareid=3690978764&uk=573533038 ...
【尚硅谷-Java学习】【项目源码】家庭记账软件
cazenove的博客
11-19 667
Utility.java import java.util.Scanner; public class Utility { private static Scanner scanner = new Scanner(System.in); public static char readMenuSelection(){ char c ; for (; ; ) { String str = readKeyBoard(1); c = str.charAt(0); if (c!
Java源码与大厂面试攻略：实战解析与核心知识点
本资源名为《面试官系统精讲Java源码及大厂真题》，是一份全面深入讲解Java编程语言基础知识和核心类的教程，特别注重实战应用与面试准备。作者文贺是一位Java技术专家和DDD/业务中台的资深实践者，拥有丰富的面试官...
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值