多线程

最新推荐文章于 2024-07-12 15:51:39 发布
最新推荐文章于 2024-07-12 15:51:39 发布
阅读量248 收藏
点赞数
分类专栏： JavaSE 文章标签： java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/pk5515/article/details/128836650
版权

标题

创建多线程方式一：继承

 * 多线程的创建，方式一：继承于Thread类
 * 1. 创建一个继承于Thread类的子类
 * 2. 重写Thread类的run() --> 将此线程执行的操作声明在run()中
 * 3. 创建Thread类的子类的对象
 * 4. 通过此对象调用start()
 * <p>
 * 例子：遍历100以内的所有的偶数

//1. 创建一个继承于Thread类的子类
class MyThread extends Thread {
    //2. 重写Thread类的run()
    @Override
    public void run() {
        for (int i = 0; i < 50; i++) {
            if(i % 2 == 0){
                System.out.println(Thread.currentThread().getName() + ":" + i);
            }
        }
    }
}


public class ThreadTest {
    public static void main(String[] args) {
        //3. 创建Thread类的子类的对象
        MyThread t1 = new MyThread();

        //4.通过此对象调用start():①启动当前线程 ② 调用当前线程的run()
        t1.start();
        //问题一：我们不能通过直接调用run()的方式启动线程。-->不可以
//        t1.run();

        //问题二：再启动一个线程，遍历100以内的偶数。不可以还让已经start()的线程去执行。会报IllegalThreadStateException
//        t1.start();
        //我们需要重新创建一个线程的对象
        MyThread t2 = new MyThread();
        t2.start();


        //如下操作仍然是在main线程中执行的。
        for (int i = 0; i < 50; i++) {
            if(i % 2 == 0){
                System.out.println(Thread.currentThread().getName() + ":" + i + "***********main()************");
            }
        }
    }
}

输出：

main:0***********main()************
Thread-1:0
Thread-0:0
Thread-1:2
Thread-1:4
main:2***********main()************
Thread-1:6
Thread-0:2
Thread-1:8
main:4***********main()************
Thread-1:10
Thread-0:4
Thread-1:12
main:6***********main()************
Thread-1:14
Thread-1:16
Thread-1:18
Thread-1:20
Thread-0:6
Thread-0:8
Thread-1:22
main:8***********main()************
main:10***********main()************
main:12***********main()************
main:14***********main()************
main:16***********main()************
Thread-1:24
Thread-0:10
Thread-0:12
Thread-0:14
Thread-0:16
Thread-1:26
main:18***********main()************
Thread-1:28
Thread-1:30
Thread-1:32
Thread-1:34
Thread-1:36
Thread-1:38
Thread-1:40
Thread-1:42
Thread-1:44
Thread-1:46
Thread-1:48
Thread-0:18
main:20***********main()************
main:22***********main()************
main:24***********main()************
main:26***********main()************
main:28***********main()************
main:30***********main()************
main:32***********main()************
main:34***********main()************
main:36***********main()************
main:38***********main()************
main:40***********main()************
main:42***********main()************
Thread-0:20
main:44***********main()************
main:46***********main()************
Thread-0:22
main:48***********main()************
Thread-0:24
Thread-0:26
Thread-0:28
Thread-0:30
Thread-0:32
Thread-0:34
Thread-0:36
Thread-0:38
Thread-0:40
Thread-0:42
Thread-0:44
Thread-0:46
Thread-0:48

Process finished with exit code 0

线程中常用方法和优先级

 * 测试Thread中的常用方法：
 * 1. start():启动当前线程；调用当前线程的run()
 * 2. run(): 通常需要重写Thread类中的此方法，将创建的线程要执行的操作声明在此方法中
 * 3. currentThread():静态方法，返回执行当前代码的线程
 * 4. getName():获取当前线程的名字
 * 5. setName():设置当前线程的名字
 * 6. yield():释放当前cpu的执行权
 * 7. join():在线程a中调用线程b的join(),此时线程a就进入阻塞状态，直到线程b完全执行完以后，线程a才
 *           结束阻塞状态。
 * 8. stop():已过时。当执行此方法时，强制结束当前线程。
 * 9. sleep(long millitime):让当前线程“睡眠”指定的millitime毫秒。在指定的millitime毫秒时间内，当前
 *                          线程是阻塞状态。
 * 10. isAlive():判断当前线程是否存活
 *
 *
 * 线程的优先级：
 * 1.
 * MAX_PRIORITY：10
 * MIN _PRIORITY：1
 * NORM_PRIORITY：5  -->默认优先级
 * 2.如何获取和设置当前线程的优先级：
 *   getPriority():获取线程的优先级
 *   setPriority(int p):设置线程的优先级
 *
 *   说明：高优先级的线程要抢占低优先级线程cpu的执行权。但是只是从概率上讲，高优先级的线程高概率的情况下
 *   被执行。并不意味着只有当高优先级的线程执行完以后，低优先级的线程才执行。
 *

多窗口卖票

例子：创建三个窗口卖票，总票数为100张.使用继承Thread类的方式（存在线程的安全问题，待解决。)

package com.pan.exer;

import org.junit.Test;

class Window extends Thread{
    private static int ticket = 30;

    @Override
    public void run(){
        while(true){
            if(ticket > 0){
                System.out.println(Thread.currentThread().getName() + ":卖票，票号为:" + ticket);
                ticket--;
            }
            else
                break;
        }
    }
}


public class WindowTest {
    @Test
    public void test1(){
        Window t1 = new Window();
        Window t2 = new Window();
        Window t3 = new Window();

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

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

输出：

窗口1:卖票，票号为:30
窗口3:卖票，票号为:30
窗口3:卖票，票号为:28
窗口3:卖票，票号为:27
窗口3:卖票，票号为:26
窗口3:卖票，票号为:25
窗口3:卖票，票号为:24
窗口2:卖票，票号为:30
窗口3:卖票，票号为:23
窗口3:卖票，票号为:21
窗口3:卖票，票号为:20
窗口3:卖票，票号为:19
窗口3:卖票，票号为:18
窗口3:卖票，票号为:17
窗口3:卖票，票号为:16
窗口3:卖票，票号为:15
窗口3:卖票，票号为:14
窗口3:卖票，票号为:13
窗口3:卖票，票号为:12
窗口3:卖票，票号为:11
窗口3:卖票，票号为:10
窗口3:卖票，票号为:9
窗口3:卖票，票号为:8
窗口3:卖票，票号为:7
窗口3:卖票，票号为:6
窗口3:卖票，票号为:5
窗口3:卖票，票号为:4
窗口3:卖票，票号为:3
窗口3:卖票，票号为:2
窗口3:卖票，票号为:1
窗口1:卖票，票号为:29
窗口2:卖票，票号为:22

创建多线程方式二：实现Runnable接口

 * 创建多线程的方式二：实现Runnable接口
 * 1. 创建一个实现了Runnable接口的类
 * 2. 实现类去实现Runnable中的抽象方法：run()
 * 3. 创建实现类的对象
 * 4. 将此对象作为参数传递到Thread类的构造器中，创建Thread类的对象
 * 5. 通过Thread类的对象调用start()


* 比较创建线程的两种方式。
 * 开发中：优先选择：实现Runnable接口的方式
 * 原因：1. 实现的方式没有类的单继承性的局限性
 *       2. 实现的方式更适合来处理多个线程有共享数据的情况。
 * 联系：public class Thread implements Runnable
 * 相同点：两种方式都需要重写run(),将线程要执行的逻辑声明在run()中。

//1. 创建一个实现了Runnable接口的类
class MThread implements Runnable{

    //2. 实现类去实现Runnable中的抽象方法：run()
    @Override
    public void run() {
        for (int i = 0; i < 100; i++) {
            if(i % 2 == 0){
                System.out.println(Thread.currentThread().getName() + ":" + i);
            }

        }
    }
}


public class ThreadTest1 {
    public static void main(String[] args) {
        //3. 创建实现类的对象
        MThread mThread = new MThread();
        //4. 将此对象作为参数传递到Thread类的构造器中，创建Thread类的对象
        Thread t1 = new Thread(mThread);
        t1.setName("线程1");
        //5. 通过Thread类的对象调用start():① 启动线程 ②调用当前线程的run()-->调用了Runnable类型的target的run()
        t1.start();

        //再启动一个线程，遍历100以内的偶数
        Thread t2 = new Thread(mThread);
        t2.setName("线程2");
        t2.start();
    }

}

多窗口卖票（使用Runable方式）

/*
* 例子：创建三个窗口卖票，总票数为40张，使用实现Runable接口的方式
* */
class Window1 implements Runnable{
    private int ticket = 40;

    @Override
    public void run() {
        while(true){
            if(ticket > 0){
                System.out.println(Thread.currentThread().getName() + ":卖票，票号为:" + ticket);
                ticket--;
            }else{
                break;
            }
        }
    }
}
public class WindowTest1{
    @Test
    public void test1(){
        Window1 w = new Window1();

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

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

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

输出：

窗口1:卖票，票号为:40
窗口3:卖票，票号为:40
窗口2:卖票，票号为:40
窗口3:卖票，票号为:38
窗口3:卖票，票号为:36
窗口3:卖票，票号为:35
窗口3:卖票，票号为:34
窗口3:卖票，票号为:33
窗口3:卖票，票号为:32
窗口3:卖票，票号为:31
窗口3:卖票，票号为:30
窗口3:卖票，票号为:29
窗口3:卖票，票号为:28
窗口3:卖票，票号为:27
窗口3:卖票，票号为:26
窗口3:卖票，票号为:25
窗口3:卖票，票号为:24
窗口3:卖票，票号为:23
窗口1:卖票，票号为:39
窗口1:卖票，票号为:21
窗口1:卖票，票号为:20
窗口1:卖票，票号为:19
窗口1:卖票，票号为:18
窗口1:卖票，票号为:17
窗口3:卖票，票号为:22
窗口3:卖票，票号为:15
窗口3:卖票，票号为:14
窗口2:卖票，票号为:37
窗口3:卖票，票号为:13
窗口3:卖票，票号为:11
窗口3:卖票，票号为:10
窗口3:卖票，票号为:9
窗口3:卖票，票号为:8
窗口3:卖票，票号为:7
窗口3:卖票，票号为:6
窗口3:卖票，票号为:5
窗口1:卖票，票号为:16
窗口3:卖票，票号为:4
窗口3:卖票，票号为:2
窗口3:卖票，票号为:1
窗口2:卖票，票号为:12
窗口1:卖票，票号为:3

进程的生命周期

在这里插入图片描述

同步代码块解决实现Runable的线程安全问题

 * 例子：创建三个窗口卖票，总票数为100张.使用实现Runnable接口的方式
 *
 * 1.问题：卖票过程中，出现了重票、错票 -->出现了线程的安全问题
 * 2.问题出现的原因：当某个线程操作车票的过程中，尚未操作完成时，其他线程参与进来，也操作车票。
 * 3.如何解决：当一个线程a在操作ticket的时候，其他线程不能参与进来。直到线程a操作完ticket时，其他
 *            线程才可以开始操作ticket。这种情况即使线程a出现了阻塞，也不能被改变。
 *
 *
 * 4.在Java中，我们通过同步机制，来解决线程的安全问题。
 *
 *  方式一：同步代码块
 *
 *   synchronized(同步监视器){
 *      //需要被同步的代码
 *
 *   }
 *  说明：1.操作共享数据的代码，即为需要被同步的代码。  -->不能包含代码多了，也不能包含代码少了。
 *       2.共享数据：多个线程共同操作的变量。比如：ticket就是共享数据。
 *       3.同步监视器，俗称：锁。任何一个类的对象，都可以充当锁。
 *          要求：多个线程必须要共用同一把锁。
 *
 *       补充：在实现Runnable接口创建多线程的方式中，我们可以考虑使用this充当同步监视器。
 *  方式二：同步方法。
 *     如果操作共享数据的代码完整的声明在一个方法中，我们不妨将此方法声明同步的。
 *
 *
 *  5.同步的方式，解决了线程的安全问题。---好处
 *    操作同步代码时，只能有一个线程参与，其他线程等待。相当于是一个单线程的过程，效率低。 ---局限性
 *

方法一

class Window1 implements Runnable{
    private int ticket = 40;
    Object obj = new Object();


    @Override
    public void run() {
        while(true) {
            synchronized (this){//synchronized (obj) {
                if (ticket > 0) {
                    System.out.println(Thread.currentThread().getName() + ":卖票，票号为:" + ticket);
                    ticket--;
                } else {
                    break;
                }
            }
        }
    }
}
public class WindowTest1{
    @Test
    public void test1(){
        Window1 w = new Window1();

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

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

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

输出：

窗口1:卖票，票号为:40
窗口3:卖票，票号为:39
窗口3:卖票，票号为:38
窗口3:卖票，票号为:37
窗口3:卖票，票号为:36
窗口3:卖票，票号为:35
窗口3:卖票，票号为:34
窗口3:卖票，票号为:33
窗口3:卖票，票号为:32
窗口3:卖票，票号为:31
窗口3:卖票，票号为:30
窗口3:卖票，票号为:29
窗口3:卖票，票号为:28
窗口3:卖票，票号为:27
窗口3:卖票，票号为:26
窗口3:卖票，票号为:25
窗口3:卖票，票号为:24
窗口3:卖票，票号为:23
窗口3:卖票，票号为:22
窗口3:卖票，票号为:21
窗口3:卖票，票号为:20
窗口3:卖票，票号为:19
窗口3:卖票，票号为:18
窗口3:卖票，票号为:17
窗口3:卖票，票号为:16
窗口3:卖票，票号为:15
窗口3:卖票，票号为:14
窗口3:卖票，票号为:13
窗口3:卖票，票号为:12
窗口3:卖票，票号为:11
窗口3:卖票，票号为:10
窗口3:卖票，票号为:9
窗口3:卖票，票号为:8
窗口3:卖票，票号为:7
窗口3:卖票，票号为:6
窗口3:卖票，票号为:5
窗口3:卖票，票号为:4
窗口3:卖票，票号为:3
窗口3:卖票，票号为:2
窗口3:卖票，票号为:1

方法二

使用同步方法处理实现Runable的线程安全问题

package com.pan.test1;
/*
* 使用同步方法处理实现Runable的线程安全问题
* */
class Window2 implements Runnable{
    private int ticket = 200;

    @Override
    public void run(){
        while(true){
            show();
        }
    }

    private synchronized void show(){//同步监视器：this
        if(ticket > 0){
            try{
                Thread.sleep(300);
            }catch (InterruptedException e){
                e.printStackTrace();
            }
            System.out.println(Thread.currentThread().getName() + ":卖票，票号为:" + ticket);
            ticket--;
        }
    }
}

public class WindowTest2 {
    public static void main(String[] args) {
        Window2 w = new Window2();

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

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

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

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

class Window4 extends Thread {


    private static int ticket = 300;

    @Override
    public void run() {

        while (true) {

            show();
        }

    }
    private static synchronized void show(){//同步监视器：Window4.class
        //private synchronized void show(){ //同步监视器：t1,t2,t3。此种解决方式是错误的
        if (ticket > 0) {

            try {
                Thread.sleep(10);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }

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


public class WindowTest3 {
    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();
    }
}

死锁问题

有死锁的代码

package com.atguigu.java1;
//死锁的演示
class A {
	public synchronized void foo(B b) { //同步监视器：A类的对象：a
		System.out.println("当前线程名: " + Thread.currentThread().getName()
				+ " 进入了A实例的foo方法"); // ①
//		try {
//			Thread.sleep(200);
//		} catch (InterruptedException ex) {
//			ex.printStackTrace();
//		}
		System.out.println("当前线程名: " + Thread.currentThread().getName()
				+ " 企图调用B实例的last方法"); // ③
		b.last();
	}

	public synchronized void last() {//同步监视器：A类的对象：a
		System.out.println("进入了A类的last方法内部");
	}
}

class B {
	public synchronized void bar(A a) {//同步监视器：b
		System.out.println("当前线程名: " + Thread.currentThread().getName()
				+ " 进入了B实例的bar方法"); // ②
//		try {
//			Thread.sleep(200);
//		} catch (InterruptedException ex) {
//			ex.printStackTrace();
//		}
		System.out.println("当前线程名: " + Thread.currentThread().getName()
				+ " 企图调用A实例的last方法"); // ④
		a.last();
	}

	public synchronized void last() {//同步监视器：b
		System.out.println("进入了B类的last方法内部");
	}
}

public class DeadLock implements Runnable {
	A a = new A();
	B b = new B();

	public void init() {
		Thread.currentThread().setName("主线程");
		// 调用a对象的foo方法
		a.foo(b);
		System.out.println("进入了主线程之后");
	}

	public void run() {
		Thread.currentThread().setName("副线程");
		// 调用b对象的bar方法
		b.bar(a);
		System.out.println("进入了副线程之后");
	}

	public static void main(String[] args) {
		DeadLock dl = new DeadLock();
		new Thread(dl).start();

		dl.init();
	}
}

解决方法：

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

Lock锁方式解决线程安全问题

 * 1. 面试题：synchronized 与 Lock的异同？
 *   相同：二者都可以解决线程安全问题
 *   不同：synchronized机制在执行完相应的同步代码以后，自动的释放同步监视器
 *        Lock需要手动的启动同步（lock()），同时结束同步也需要手动的实现（unlock()）
 *
 * 2.优先使用顺序：
 * Lock  同步代码块（已经进入了方法体，分配了相应资源）  同步方法（在方法体之外）
 *

class Window implements Runnable{
    private int ticket = 100;
    //1、实例化ReentrantLock
    private ReentrantLock lock = new ReentrantLock();

    @Override
    public void run() {
        while(true) {
            try {
                //2、调用锁定方法lock()
                lock.lock();
                if (ticket > 0) {
                    try {
                        Thread.sleep(50);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                    System.out.println(Thread.currentThread().getName() + "：卖票，票号为：" + ticket);
                    ticket--;
                } else break;
            }finally {
                //3、调用解锁方法：unlock()
                lock.unlock();
            }
        }
    }
}
public class LockTest {
    public static void main(String[] args) {
        Window w = new Window();
        Thread t1 = new Thread(w);
        Thread t2 = new Thread(w);
        Thread t3 = new Thread(w);

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

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

    }
}
//E:\java\javaSE\thread\src\com\pan\test1\LockTest.java

练习

 * 银行有一个账户。
 *有两个储户分别向同一个账户存2000元，每次存10，存200次。每次存完打印账户余额。

class Custmer implements Runnable{
    private double balance = 0;
    @Override
    public void run(){
        for(int i = 0; i < 200; i++){
            deposit(10);
        }
    }
    public synchronized void deposit(double amt){
        if(amt > 0){
            balance += amt;
            try{
                Thread.sleep(1);

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

    }
}

public class AccountTest {
    public static void main(String[] args) {
        Custmer custmer = new Custmer();

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

        t1.start();
        t2.start();
    }
}
//E:\java\javaSE\thread\src\com\pan\exer\AccountTest.java

线程的通信

栗子：使用两个线程打印1-100，线程1和2交替打印。

 * 涉及到的三个方法：
 * wait():一旦执行此方法，当前线程就进入阻塞状态，并释放同步监视器，其他线程可以拿到同步监视器进入同步代码块中。
 * notify():一旦执行此方法，就会唤醒被wait的一个线程。如果有多个线程被wait，就唤醒优先级高的那个。
 * notifyAll():一旦执行此方法，就会唤醒所有被wait的线程。
 *
 * 说明：
 * 1.wait()，notify()，notifyAll()三个方法必须使用在同步代码块或同步方法中。
 * 2.wait()，notify()，notifyAll()三个方法的调用者必须是同步代码块或同步方法中的同步监视器。
 *    否则，会出现IllegalMonitorStateException异常
 * 3.wait()，notify()，notifyAll()三个方法是定义在java.lang.Object类中。
 *
 * 面试题：sleep() 和 wait()的异同？
 * 1.相同点：一旦执行方法，都可以使得当前的线程进入阻塞状态。
 * 2.不同点：1）两个方法声明的位置不同：Thread类中声明sleep() , Object类中声明wait()
 *          2）调用的要求不同：sleep()可以在任何需要的场景下调用。 wait()必须使用在同步代码块或同步方法中
 *          3）关于是否释放同步监视器：如果两个方法都使用在同步代码块或同步方法中，sleep()不会释放锁，wait()会释放锁。
 *
class Number implements Runnable{
    private int number = 1;
    @Override
    public void run() {
        while(true){
            synchronized (this) {
                this.notify();
                if(number <= 100){
                    try{
                        Thread.sleep(10);
                    }catch (InterruptedException e){
                        e.printStackTrace();
                    }
                    System.out.println(Thread.currentThread().getName()+ ":" + number);
                    number++;
                    try {
                        this.wait();//使调用wait()的方法进入阻塞状态
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }
                else{
                    break;
                }
            }
        }
    }
}
public class CommunicationTest {
    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();
    }
}
//E:\java\javaSE\thread\src\com\pan\exer\CommunicationTest.java

创建多线程的方式三：实现Callable接口

在这里插入图片描述

//1.创建一个实现Callable的实现类
class NumThread implements Callable{

    //2.实现call方法，将此线程需要执行的操作声明在call()中
    @Override
    public Object call() throws Exception {
        int sum = 0;
        for(int i = 1; i < 101; i++){
            if(i % 2 == 0){
                System.out.println(Thread.currentThread().getName() + ":" + 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方法的返回值
            //get()返回值就是FutureTask构造器参数Callable实现重写的call()的返回值
            Object sum = futureTask.get();
            System.out.println("总和为：" + sum);
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}

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

在这里插入图片描述

package com.pan.test1;

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

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

class NumberThread2 implements Runnable{
    @Override
    public void run() {
        for (int i = 0; i < 101; 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 service1 = (ThreadPoolExecutor) service;
        //设置线程池的属性
//        System.out.println(service.getClass());
//        service1.setCorePoolSize(15);
//        service1.setKeepAliveTime();

        //2.执行指定的线程操作，需要提供实现Runnable接口或者Callable接口实现类的对象
        service.execute(new NumberThread1());//适用于Runnable
        service.execute(new NumberThread2());
        //service.submit(Callable callable);//适用于Callable
        //3.关闭连接池
        service.shutdown();
    }
}
pk5515
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
Linux 多线程原理深剖
qq_61500888的博客
12-24 3万+
带你一命通关 Linux 多线程原理 三十分钟手撕底层内涵
stm32单片机多线程实例
12-03
多线程是实现复杂任务并发执行的关键技术，能够提高资源利用率，优化系统响应时间。在STM32上实现多线程，通常会借助实时操作系统（RTOS）如RT-Thread。 RT-Thread是一个轻量级、开源的实时操作系统，它为STM32等微...
Java多线程超详解
weixin_44797490的博客
06-11 14万+
引言 随着计算机的配置越来越高，我们需要将进程进一步优化，细分为线程，充分提高图形化界面的多线程的开发。这就要求对线程的掌握很彻底。 那么话不多说，今天本帅将记录自己线程的学习。 线程的相关API //获取当前线程的名字 Thread.currentThread().getName() 1.start():1.启动当前线程2.调用线程中的run方法 2.run():通常需要重写Thread类中的此...
万字图解Java多线程
qq_35598736的博客
09-06 5万+
前言 java多线程我个人觉得是javaSe中最难的一部分，我以前也是感觉学会了，但是真正有多线程的需求却不知道怎么下手，实际上还是对多线程这块知识了解不深刻，不知道多线程api的应用场景，不知道多线程的运行流程等等，本篇文章将使用实例+图解+源码的方式来解析java多线程。 文章篇幅较长，大家也可以有选择的看具体章节，建议多线程的代码全部手敲，永远不要相信你看到的结论，自己编码后运行出来的，才是自己的。 什么是java多线程? 进程与线程 进程 当一个程序被运行，就开启了一个进程， 比如启动了qq，w.
Java多线程（超详细！）
一只小菜鸡
05-13 12万+
1、什么是进程？什么是线程？ 进程是:一个应用程序（1个进程是一个软件）。 线程是：一个进程中的执行场景/执行单元。 注意：一个进程可以启动多个线程。 eg.对于java程序来说，当在DOS命令窗口中输入： java HelloWorld 回车之后。 会先启动JVM，而JVM就是一个进程。 JVM再启动一个主线程调用main方法。 同时再启动一个垃圾回收线程负责看护，回收垃圾。 最起码，现在的java程序中至少有两个线程并发， 一个是垃圾回收线程，一个是执行main方法的主线程。 3、进程和线程是什么关系？
C++多线程详细讲解
qq_45439571的博客
03-19 4万+
本文是纯转载，觉得大佬写的非常好！如有侵权可以删除 链接: link. C++多线程基础教程 目录 1 什么是C++多线程？ 2 C++多线程基础知识 2.1 创建线程 2.2 互斥量使用 lock()与unlock(): lock_guard(): unique_lock: condition_variable: 2.3 异步线程 async与future： shared_future 2.4 原子类型automic 实例 生产者消费者问题 4 C++多线程高级知识 4.1 线程池 线程池基础知识 线程池
一文详解C++多线程
非晚非晚的博客
04-25 7万+
传统的C++（C++11之前）中并没有引入线程这个概念，在C++11出来之前，如果我们想要在C++中实现多线程，需要借助操作系统平台提供的API，比如Linux的<pthread.h>，或者windows下的<windows.h> 。C++11提供了语言层面上的多线程，包含在头文件<thread>中。它解决了跨平台的问题，提供了管理线程、保护共享数据、线程间同步操作、原子操作等类。C++11 新标准中引入了5个头文件来支持多线程编程，如下图所示：
java多线程（超详细）
zdl66的博客
08-14 10万+
进程就是正在运行中的程序（进程是驻留在内存中的）是系统执行资源分配和调度的独立单位每一进程都有属于自己的存储空间和系统资源注意：进程A和进程B的内存独立不共享。
Python多线程详解
千山暮彩
10-30 5万+
现代计算机CPU物理核心普遍比较多，我们在编写程序时经常会用到多线程技术来提高程序运行的效率。作为python萌新，我在掌握基本语法后就很想摆弄一下python的多线程，使用起来确实很有python的特点，代码量少、操作方便。之后断断续续写了一些多线程程序，直到今天下午逛论坛，看到很多人说python多线程机制的一些内情，我才意识到自己有多愚蠢哈哈。我把自己学到的内容系统的整理一下，以备后忘，也帮帮后来者。
Java多线程学习（吐血超详细总结）
热门推荐
Evankaka的专栏
03-14 41万+
本文主要讲了java中多线程的使用方法、线程同步、线程数据传递、线程状态及相应的一些线程函数用法、概述等。
多线程(一)：创建线程和线程的常用方法
人不风流枉少年
09-01 24万+
一：为什么要学多线程 应付面试 ：多线程几乎是面试中必问的题，所以掌握一定的基础知识是必须的。 了解并发编程：实际工作中很少写多线程的代码，这部分代码一般都被人封装起来了，在业务中使用多线程的机会也不是很多(看具体项目)，但是作为一个高级程序员如果不会多线程是说不过去的。 二：进程与线程 进程 进程是资源（CPU、内存等）分配的基本单位，它是程序执行时的一个实例。程序运行时系统...
多线程测试
09-21
在计算机科学领域，多线程是一种程序设计技术，它允许应用程序同时执行多个任务或子任务。这极大地提高了软件的效率和响应性，特别是在现代多核处理器的环境下。本主题将深入探讨多线程的实现方式及其与单线程的对比...
大漠多线程模板_大漠_大漠多线程_
09-30
"大漠多线程模板"是一个专门针对C#开发的多线程处理框架，它为开发者提供了便捷的方式来管理和优化多线程应用。这个框架由知名开发者"大漠"创建，旨在简化复杂的并发编程，提高代码的可读性和可维护性。 多线程允许...
安卓多线程
04-16
安卓多线程，安卓高级开发中，必备技能，项目开发中都要使用
多线程介绍
10-21
多线程（英语：multithreading），是指从软件或者硬件上实现多个线程并发执行的技术。具有多线程能力的计算机因有硬件支持而能够在同一时间执行多于一个线程，进而提升整体处理性能。具有这种能力的系统包括对称多...
配置Java开发环境
Broken_x的博客
07-10 1435
Java开发环境配置
java版的上门家政系统和PHP版的上门家政有什么区别？
最新发布
baina666的博客
07-12 303
综上所述，Java版和PHP版的上门家政系统各有优缺点，选择哪种语言主要取决于项目的具体需求、预算、开发团队的技术栈以及未来的扩展计划等因素。同时，由于Java生态系统的复杂性和多样性，也可能需要投入更多的时间和资源来学习和掌握相关的技术和工具。Java版：Java拥有庞大的生态系统和丰富的第三方库，这为家政系统的开发和扩展提供了强大的支持。Java版：由于Java的编译执行机制和高效的垃圾回收算法，Java版家政系统通常具有更高的运行效率和更好的性能表现，尤其是在处理高并发、大数据量等复杂场景时。
关于static定义初始化块和静态变量以及初始化块的执行顺序问题
你我约定有三的博客
07-08 416
第二步：在类加载的时候，按照从上到下执行static修饰的代码，此时执行static Test2 test1 = new Test2()，也就是创建出一个名为test1的对象。第六步：此时除了main方法，所有由static修饰的代码全部执行完毕(static修饰的代码只执行一次)，类初始化完成，开始执行main方法，main方法中只有一条语句(中的代码,此时输出aa以及a的值(由于第一步没赋初值，并且给了默认值为0 所以输出0)//首先输出a的值为10 然后输出bb，最后将a的值定义为11。
java Object 转 Integer
servepeople的博客
07-09 1403
在 Java 中，可以通过多种方法将一个Object转换为Integer。

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

pk5515

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值