多线程..

最新推荐文章于 2024-07-02 00:50:11 发布
最新推荐文章于 2024-07-02 00:50:11 发布
阅读量922 收藏 10
点赞数 10
文章标签： java 开发语言
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_70851493/article/details/139455934
版权

线程定义：线程是操作系统能够进行运算调度的最小单位，它被包含在进程之中，是进程中实际运作单位。简单来说，应用软件中相互独立，可以同时运作的功能。

多线程作用：有了多线程，我们就可以让程序同时做多件事情。

应用场景：只要你想让多个事件同时运行就需要用到多线程。

并发：在同一时刻，有多个指令在单个CPU上交替执行。

并行：在同一时刻，有多个指令在多个CPU上同时执行。

多线程的实现方式

1.继承Thread类的方式进行执行

步骤：

自己定义一个类继承Thread

重写run方法

创建子类的对象，并启动线程。

public class MyThread extends Thread{
	@Override
	public void run() {
		for(int i=0;i<10;i++) {
			System.out.println("Hello");
		}
	}

}

public class test {
    public static void main(String [] args)  {
    	//创建子类对象，开启线程
    	MyThread mt=new MyThread();
    	mt.start();
	 }
}

2.实现Runnable接口的方式进行实现

步骤：

自己定义一个类实现Runnable接口

重写里面的run方法

创建自己类的对象

创建一个Thread类的对象，并开启线程。

public class MyThread implements Runnable{
	@Override
	public void run() {
		for(int i=0;i<10;i++) {
			System.out.println("world");
		}
	}

}

public class test {
    public static void main(String [] args)  {
    	//创建自己类的对象
    	MyThread mt=new MyThread();
    	//创建Thread对象，并开启线程
    	Thread t=new Thread(mt);
    	t.start();
	 }
}

 

若想看看两个线程的相互执行，获取线程的名字：

public class MyThread implements Runnable{
	//在此获取线程的名字
	@Override
	public void run() {
		for(int i=0;i<10;i++) {
		Thread t=Thread.currentThread();//获取当前线程对象
		System.out.println(t.getName()+":world");
		}
	}

}

public class test {
    public static void main(String [] args)  {
    	//创建自己类的对象
    	MyThread mt=new MyThread();
    	//创建Thread对象，并开启线程
    	Thread t1=new Thread(mt);
    	Thread t2=new Thread(mt);
    	//给线程设置名字
    	t1.setName("线程1");
    	t2.setName("线程2");
    	t1.start();
    	t2.start();
	 }
}

3.利用Callable接口和Future接口方式实现

特点：可以获取多线程运行的结果。

1）创建一个MyCallable类实现Callable接口；

2）重写call方法（是有返回值的，表示多线程运行的结果）；

3）创建MyCallable的对象（表示多线程要执行的任务）；

4）创建FutureTask的对象（作用管理多线程的运行结果）；

5）创建Thread类的对象，并启动（表示线程）。

public class MyCallable implements Callable<Integer>{
    //计算1~10的和
	@Override
	public Integer call() throws Exception {
		int sum=0;
		for(int i=0;i<=10;i++) {
			sum+=i;
		}
		return sum;
	}

}
public class test {
    public static void main(String [] args) throws InterruptedException, ExecutionException  {
    	MyCallable mc=new MyCallable();
    	FutureTask<Integer> ft=new FutureTask<>(mc);//管理多线程运行结果
    	Thread t=new Thread(ft);
    	t.start();//开启线程
    	//获取返回值
         Integer sum=ft.get();
         System.out.println(sum);
	 }
}

多线程的成员方法

获取与设置线程的名字

注：若我们未给线程设置名字，线程也有默认的名字，格式：Thread-X（X为序号，从0开始）。

若我们要给线程设置名字，可以用set方法，也可以用构造方法（调用父类的构造方法）设置。

1）用set进行设置。

public class MyThread extends Thread{
	@Override
	public void run() {
		for(int i=0;i<10;i++) {
			//获取线程名字
			System.out.println(getName()+":"+i);
		}
	}

}

public class test {
    public static void main(String [] args)  {
    	MyThread t1=new MyThread();
    	MyThread t2=new MyThread();
    	//设置线程名字，用set方法设置
    	t1.setName("线程1");
    	t2.setName("线程2");
    	t1.start();
    	t2.start();
	 }
}

线程之间交替运行。 

2）用构造方法进行设置

public class MyThread extends Thread{
	public MyThread() {//调用父类的构造方法
		
	}
	public MyThread(String name) {
		super(name);
	}
	@Override
	public void run() {
		for(int i=0;i<10;i++) {
			System.out.println(getName()+":"+i);
		}
	}

}
public class test {
    public static void main(String [] args)  {
    	MyThread t1=new MyThread("飞机");
    	MyThread t2=new MyThread("鼠标");
    	t1.start();
    	t2.start();
	 }
}

线程休眠

static void sleep(long time)——让线程休眠指定时间，单位毫秒。

注：哪条线程执行到这个方法，那么哪条线程就会在这停留对应的时间。当时间到了之后，线程会自动醒来，执行下面的代码。

public class MyThread extends Thread{
	public MyThread() {//调用父类的构造方法
		
	}
	public MyThread(String name) {
		super(name);
	}
	@Override
	public void run() {
		for(int i=0;i<10;i++) {
			try {
				Thread.sleep(1000);//每个一秒打印一个数据
			} catch (InterruptedException e) {
				// TODO Auto-generated catch block
				e.printStackTrace();
			}
			System.out.println(getName()+":"+i);
		}
	}

}
public class test {
    public static void main(String [] args)  {
    	MyThread t1=new MyThread("飞机");
    	MyThread t2=new MyThread("鼠标");
    	t1.start();
    	t2.start();
	 }
}

线程的优先级

在java中使用抢占式调度，其特点为随机性。优先级为1~10，默认优先级为5，优先级越高，抢到CPU的概率越大，但并不是百分之一百抢到CPU。

public class MyThread extends Thread{
	@Override
	public void run() {
		for(int i=0;i<7;i++) {
			System.out.println(getName()+":"+i);
		}
	}
}
public class test {
    public static void main(String [] args)  {
    	MyThread t1=new MyThread();
    	MyThread t2=new MyThread();
    	//设置线程名字
    	t1.setName("键盘");
    	t2.setName("鼠标");
    	//设置线程的优先级
    	t1.setPriority(1);
    	t2.setPriority(10);
    	t1.start();
    	t2.start();
	 }
}

鼠标优先级大，鼠标先执行完毕。

守护线程

当其他非守护线程结束后，守护线程也会陆续结束（一般不会执行完毕）。

public class MyThread1 extends Thread{
	@Override
	public void run() {
		for(int i=0;i<8;i++) {
			System.out.println(getName()+":"+i);
		}
	}
}
public class MyThread2 extends Thread{
	@Override
	public void run() {
		for(int i=0;i<100;i++) {
			System.out.println(getName()+":"+i);
		}
	}
}
public class test {
    public static void main(String [] args)  {
    	MyThread1 t1=new MyThread1();
    	MyThread2 t2=new MyThread2();
    	//设置线程名字
    	t1.setName("线程");
    	t2.setName("备份");
    	//将t2设置为守护线程
    	t2.setDaemon(true);
    	t1.start();
    	t2.start();
	 }
}

礼让线程

礼让线程也叫出让线程，作用：尽可能使结果均匀一点。

public class MyThread extends Thread{
	@Override
	public void run() {
		for(int i=0;i<8;i++) {
			System.out.println(getName()+":"+i);
			Thread.yield();//出让线程
		}
	}
}
public class test {
    public static void main(String [] args)  {
    	MyThread t1=new MyThread();
    	MyThread t2=new MyThread();
    	//设置线程名字
    	t1.setName("线程1");
    	t2.setName("线程2");
    	
    	t1.start();
    	t2.start();
	 }
}

插入线程

public class MyThread extends Thread{
	@Override
	public void run() {
		for(int i=0;i<100;i++) {
			System.out.println(getName()+":"+i);
		}
	}
}
public class test {
    public static void main(String [] args) throws InterruptedException  {
    	MyThread t1=new MyThread();	
    	t1.setName("土豆");
    	t1.start();
    	t1.join();//插入线程，将土豆线程插入到main线程之前
    	for(int i=0;i<10;i++) {
    		System.out.println("main线程"+i);
    	}
	 }
}

线程的生命周期

同步代码块

把操作共享的代码锁起来。

锁对象一定要求是唯一的。

 利用同步代码块可解决线程安全问题。若没有锁，可能会出现数据重复，数据超出要求的范围等等问题。

练习

某电影院目前正在上映国产大片，共有100张票，而它有3个窗口卖票，请设计一个程序模拟该电影院卖票。

public class MyThread extends Thread{
	//设置一个静态数据，表示这个类所有对象可以共享
	  static int ticket=0;//票数
	  static Object obj=new Object();//锁对象一定要是唯一的
	@Override
	public void run() {
		while(true) {
			synchronized(obj) {
			if(ticket<100) {
				try {
					Thread.sleep(100);//数据慢慢的输出
				} catch (InterruptedException e) {
					// TODO Auto-generated catch block
					e.printStackTrace();
				}
				ticket++;
				System.out.println(getName()+"今天卖出第"+ticket+"票");
			}else {
				break;
			}
			}
		}
	}
}
public class test {
    public static void main(String [] args)  {
    	MyThread t1=new MyThread();
    	MyThread t2=new MyThread();
    	MyThread t3=new MyThread();
    	//设置名字
    	t1.setName("窗口1");
    	t2.setName("窗口2");
    	t3.setName("窗口3");
    	t1.start();
    	t2.start();
    	t3.start();
	 }
}

同步方法

就是把synchronized关键字加到方法上。

同步方法是用同步代码块提取方法，改编而来的。

练习

某电影院目前正在上映国产大片，共有100张票，而它有3个窗口卖票，请设计一个程序模拟该电影院卖票。（使用同步方法完成，技巧：先构建好同步代码块，在进行变换）

public class MyThread implements Runnable{//使用第二种方法
    int ticket=0;//使用第二种方法创建对象，不用设置这个为静态的
    @Override
    public void run() {
        while(true) {       
                if (mehod()) break;         
        }

    }
    private synchronized boolean mehod() {//同步方法
        if(ticket==100) {
            return true;
        }else {
            try {
                Thread.sleep(100);//若想要看到多个线程交织进行，可采用sleep让线程睡一会
            } catch (final InterruptedException e) {
                // TODO Auto-generated catch block
                e.printStackTrace();
            }
            ticket++;
            System.out.println(Thread.currentThread().getName()+"今天卖了第"+ticket+"张票");
        }
        return false;
    }


}

public class test1 {
    public static void main(String[] args) {
        MyThread mt=new MyThread();
        Thread t1=new Thread(mt);
        Thread t2=new Thread(mt);
        Thread t3=new Thread(mt);
        t1.setName("窗口1");
        t2.setName("窗口2");
        t3.setName("窗口3");
        t1.start();
        t2.start();
        t3.start();
    }
}

Lock锁


 练习

某电影院目前正在上映国产大片，共有100张票，而它有3个窗口卖票，请设计一个程序模拟该电影院卖票。（利用Lock锁进行）

在Lock锁当中利用try-catch-finall来进行开锁关锁。，将while循环中的主体程序写完之后，从获得锁开始后利用快捷方法生成try-catch-finall，finally中写释放锁。

public class MyThread extends Thread{
    //设置一个静态数据，表示这个类所有对象可以共享
    static int ticket=0;
    Lock lock=new ReentrantLock();//创建一个锁对象
    @Override
    public void run() {
        while(true) {
          //  synchronized (MyThread.class) {
            lock.lock();//获得锁
            try {
                if (ticket < 100) {
                        Thread.sleep(100);//数据慢慢的输出
                    ticket++;
                    System.out.println(getName() + "今天卖出第" + ticket + "票");
                } else {
                    break;
                }
            } catch (InterruptedException e) {
                throw new RuntimeException(e);
            } finally {
                lock.unlock();//释放锁
            }
            // }
        }
    }
}
public class test1 {
    public static void main(String[] args) {
        MyThread t1=new MyThread();
        MyThread t2=new MyThread();
        MyThread t3=new MyThread();
        //设置名字
        t1.setName("窗口1");
        t2.setName("窗口2");
        t3.setName("窗口3");
        t1.start();
        t2.start();
        t3.start();
    }
    }

书写进程步骤：

生产者和消费者（等待唤醒机制）

生产者消费者模式是一个十分经典的多线程协作的模式。

例如：吃货和厨师（消费者和生产者）

常见方法：

实现方法1：基本方法 

 有：生产者、消费者、控制生产者和消费者的代码

先写中间：

public class Desk {//中间变量
    //作用：控制消费者和生产者的代码
    //定义桌子状态，0无面条，1有面条
    public static int state=0;
    //定义吃货最大能吃多少,总个数
    public static int count=10;
    //定义锁对象
    public static Object lock=new Object();
}

消费者：

public class Eat extends Thread{//消费者
    //循环
    //同步代码块（同步方法，锁方法均可）
    //判断共享数据是否到末尾（先写到了末尾，再写未到末尾）
    @Override
    public void run(){
        while(true){
            synchronized (Desk.lock){//锁对象
                //判断共享数据是否到末尾
                if(Desk.count==0){
                    break;
                }else{
                    //先判断桌子上物品状态
                    if(Desk.state==0){
                        //如果没有消费者等待
                        try {
                            Desk.lock.wait();
                        } catch (InterruptedException e) {
                            throw new RuntimeException(e);
                        }
                    }else{
                        //如果有
                        Desk.count--;
                        System.out.println("这个人还能再吃"+Desk.count+"碗饭");
                        //吃完唤醒厨师继续做
                        Desk.lock.notifyAll();
                        //修改桌子状态
                        Desk.state=0;
                    }

                }
            }
        }
    }
}

生产者：

public class Cook extends Thread{//生产者
    @Override
    public void run(){
        while(true){
            synchronized (Desk.lock){
                if(Desk.count==0){
                    break;
                }else{
                    //判断桌子状态
                    if(Desk.state==1){
                        //如果有，就等待
                        try {
                            Desk.lock.wait();
                        } catch (InterruptedException e) {
                            throw new RuntimeException(e);
                        }
                    }else{
                        //如果没有
                        System.out.println("厨师做了一碗面");
                        //修改桌子状态
                        Desk.state=1;
                        //唤醒消费者
                        Desk.lock.notifyAll();
                    }
                }
            }
        }
    }
}

测试类：

public class test1 {
    public static void main(String[] args) {
        Cook c=new Cook();
        Eat e=new Eat();
        //设置名字
        c.setName("厨师：");
        e.setName("吃货");
        //开启线程
        c.start();
        e.start();
    }
    }

实现方法2：阻塞队列方法实现

 阻塞队列的接口和实现类：

public class Cook extends Thread{//生产者
    ArrayBlockingQueue<String> queue;

    public Cook(ArrayBlockingQueue<String> queue) {
        this.queue=queue;
    }

    @Override
    public void run(){
        while(true){
            //调用阻塞队列将面条放入
            try {
                queue.put("面条");
                System.out.println("厨师放了一碗面条");
            } catch (InterruptedException e) {
                throw new RuntimeException(e);
            }
        }
    }
}
public class Eat extends Thread{//消费者
    ArrayBlockingQueue<String> queue;

    public Eat(ArrayBlockingQueue<String> queue) {
        this.queue=queue;
    }

    @Override
    public void run(){
        while(true){
            try {
                String food=queue.take();
                System.out.println(food);
            } catch (InterruptedException e) {
                throw new RuntimeException(e);
            }


        }
    }
}
public class test1 {
    public static void main(String[] args) {
      //创建阻塞队列
        ArrayBlockingQueue<String> queue=new ArrayBlockingQueue<>(10);//定义阻塞队列中的队列长度
        Cook c=new Cook(queue);
        Eat e=new Eat(queue);
        c.setName("厨师");
        e.setName("吃货");
        c.start();
        e.start();
    }
    }

线程的六种状态

综合练习

练习1：抢红包

（因为获取Double类型的随机数只能在JDK17中，抢红包实际抢到的是小数，在此题下理想化，认为是整数）
抢红包也用到了多线程。假设: 100块，分成了3个包，现在有5个人去抢。其中，红包是共享数据。5个人是5条线程。
打印结果如下:
XXX抢到了XXX元
XXX抢到了XXX元
XXX抢到了XXX元
XXX没抢到
XXX没抢到

package test1;
import java.util.Random;
public class MyThread extends  Thread{
    //定义静态变量
    static  int money=100;//总金额
    static int count=3;//红包个数
    static final int MIN=1;//抢到的金额的最小值
    @Override
    public void run() {
        synchronized (MyThread.class) {
            //判断金额
            if (money == 0) {
                System.out.println(getName() + "没有抢到红包");
            } else {
                //判断红包个数
                int prize = 0;//中奖金额
                if (count == 1) {
                    //只剩一个红包，中奖金额就是余额
                    prize = money;
                } else {
                    //进行随机数，获取红包金额
                    Random r = new Random();
                    int bound = money - (count - 1) * MIN;
                    prize = r.nextInt(bound);
                    if (prize < MIN) {
                        prize = MIN;
                    }
                }
                money = money - prize;
                count--;
                System.out.println(getName() + "抢到了" + prize + "元");
            }
        }
    }
}

public class test1 {
    public static void main(String[] args) {
        MyThread t1=new MyThread();
        MyThread t2=new MyThread();
        MyThread t3=new MyThread();
        MyThread t4=new MyThread();
        MyThread t5=new MyThread();
        t1.setName("张三");
        t2.setName("李四");
        t3.setName("王五");
        t4.setName("赵六");
        t5.setName("导航");
        t1.start();
        t2.start();
        t3.start();
        t4.start();
        t5.start();
    }
    }

练习2：抽奖池抽奖

有一个抽奖池，该抽奖池中存放了奖励的金额，该抽奖池中的奖项为{10,5,20,50,100,200,500,800,2,80,300,700};
创建两个抽奖箱(线程)设置线程名称分别为“ 抽奖箱1”，‘ '抽奖箱2”随机从抽奖池中获取奖项元素并打印在控制台上格式如下:
每次抽出一个奖项就打印一个(随机)
抽奖箱1又产生了一个10元大奖
抽奖箱1又产生了一个100元大奖
抽奖箱2又产生了一个700元大奖
分析：可用集合和数组进行，但数组去重比较复杂，利用集合完成。

public class MyThread extends  Thread {
    ArrayList<Integer> list;//静态变量

    //可以利用构造方法
    public MyThread(ArrayList<Integer> list) {
        this.list = list;
    }

    @Override
    public void run() {
        while (true) {
            synchronized (MyThread.class) {
                if (list.size() == 0) {
                    break;
                } else {
                    Collections.shuffle(list);//打乱list数据
                    int prize = list.remove(0);
                    System.out.println(getName() + "又产生了一个" + prize + "大奖");
                }
            }
            try {
                Thread.sleep(100);//目的是可以让两个线程交替进行显示
            } catch (InterruptedException e) {
                throw new RuntimeException(e);
            }

        }
    }
}

public class test1 {
    public static void main(String[] args) {
        ArrayList<Integer> list=new ArrayList<>();
        Collections.addAll(list,10,5,20,50,100,200,500,800,2,80,300,700);
        MyThread t1=new MyThread(list);
        MyThread t2=new MyThread(list);
        t1.setName("抽奖箱1");
        t2.setName("抽奖箱2");
        t1.start();
        t2.start();
    }
    }

练习3：多线程统计并求最大值

在上一题基础上继续完成如下需求:
每次抽的过程中，不打印，抽完时一次性打印(随机)，在此次抽奖过程中，抽奖箱1总共产生了6个奖项。
分别为: 10,20,100,500,2,300最高奖项为300元，总计额为932元在此次抽奖过程中，抽奖箱2总共产生了6个奖项。
分别为: 5, 50,200,800,80,700最高奖项为800元，总计额为1835元

解法一：对第一个程序进行改编
 

public class MyThread extends  Thread{
    ArrayList<Integer> list;//静态变量
    //可以利用构造方法
    public MyThread(ArrayList<Integer> list){
        this.list=list;
    }
    //创建两个集合来存放数据
    static  ArrayList<Integer> list1=new ArrayList<>();
   static ArrayList<Integer> list2=new ArrayList<>();
    @Override
    public void run(){
        while(true){
          synchronized (MyThread.class) {
            if(list.size()==0){
                if("抽奖箱1".equals(getName())){
                    System.out.println("抽奖箱1"+list1);
                    int max=0;
                    int count=0;
                    for(int i=0;i<list1.size();i++){
                        if(max<= list1.get(i)){
                            max=list1.get(i);
                        }
                        count+=list1.get(i);
                    }
                    System.out.println("抽奖箱1最大奖"+max);
                    System.out.println("抽奖箱1总计"+count);
                }else if("抽奖箱2".equals(getName())) {
                    System.out.println("抽奖箱2"+list2);
                    int max=0;
                    int count=0;
                    for(int i=0;i<list2.size();i++){
                        if(max<= list2.get(i)){
                            max=list2.get(i);
                        }
                        count+=list2.get(i);
                    }
                    System.out.println("抽奖箱2最大奖"+max);
                    System.out.println("抽奖箱2总计"+count);
                }
                break;
            }else{
                Collections.shuffle(list);//打乱list数据
                int prize=list.remove(0);
               //进行判断
                if("抽奖箱1".equals(getName())){
                    list1.add(prize);
                }else if("抽奖箱2".equals(getName())){
                    list2.add(prize);
                }
            }
        }
}
        try {
            Thread.sleep(10);//目的是可以让两个线程交替进行显示
        } catch (InterruptedException e) {
            throw new RuntimeException(e);
        }
    }

}

解法二：线程栈

public class MyThread extends  Thread {
    ArrayList<Integer> list;//静态变量

    //可以利用构造方法
    public MyThread(ArrayList<Integer> list) {
        this.list = list;
    }

    @Override
    public void run() {
        ArrayList<Integer> List=new ArrayList<>();
        while (true) {
            synchronized (MyThread.class) {
                if (list.size() == 0) {
                    System.out.println(getName()+List);
                    break;
                } else {
                    Collections.shuffle(list);//打乱list数据
                    int prize = list.remove(0);
                    List.add(prize);
                }
            }
            try {
                Thread.sleep(100);//目的是可以让两个线程交替进行显示
            } catch (InterruptedException e) {
                throw new RuntimeException(e);
            }

        }
    }
}

练习4：多线程之间的比较

在上一题基础上继续完成如下需求:在此次抽奖过程中，抽奖箱1总共产生了6个奖项，分别为: 10,20,100,500,2,300，最高奖项为300元，总计额为932元
在此次抽奖过程中，抽奖箱2总共产生了6个奖项，分别为: 5,50,200,800,80,700
最高奖项为800元，总计额为1835元
在此次抽奖过程中,抽奖箱2中产生了最大奖项，该奖项金额为800元
分析：最大奖项应该这两个线程结束后再比较，采用有返回值的线程创建方法，将最大值返回后打印。

public class MyCallable implements Callable<Integer> {
    ArrayList<Integer> list;//静态变量

    //可以利用构造方法
    public MyCallable(ArrayList<Integer> list) {
        this.list = list;
    }

    @Override
    public Integer call() throws Exception {
        ArrayList<Integer> List=new ArrayList<>();
        while (true) {
            synchronized (MyCallable.class) {
                if (list.size() == 0) {
                    System.out.println(Thread.currentThread().getName()+List);
                    break;
                } else {
                    Collections.shuffle(list);//打乱list数据
                    int prize = list.remove(0);
                    List.add(prize);
                }
            }
                Thread.sleep(100);//目的是可以让两个线程交替进行显示
        }
        //把集合中的最大值返回
        if(List.size()==0){
            return null;
        }else{
           return Collections.max(List);
        }

    }
}

public class test1 {
    public static void main(String[] args) throws ExecutionException, InterruptedException {
        ArrayList<Integer> list=new ArrayList<>();
        Collections.addAll(list,10,5,20,50,100,200,500,800,2,80,300,700);
        MyCallable mc=new MyCallable(list);
        FutureTask<Integer> ft1=new FutureTask<>(mc);
        FutureTask<Integer> ft2=new FutureTask<>(mc);
        Thread t1=new Thread(ft1);
        Thread t2=new Thread(ft2);
        t1.setName("抽奖箱1");
        t2.setName("抽奖箱2");
        t1.start();
        t2.start();
        int max1=ft1.get();
        int max2=ft2.get();
        System.out.println(max1);
        System.out.println(max2);
    }
    }

线程池

核心原理：

创建线程池

创建一个没有上限的线程池：

public class MyRunnable implements Runnable{

    @Override
    public void run() {
        for(int i=1;i<=100;i++){
            System.out.println(Thread.currentThread().getName()+"--"+i);
        }
    }
}
public class test1 {
    public static void main(String[] args)  {
        //创建线程池对象
      ExecutorService poll= Executors.newCachedThreadPool();
      //提交任务
        poll.submit(new MyRunnable());
        poll.submit(new MyRunnable());
        poll.submit(new MyRunnable());
        //线程池一般不会关闭
    }
    }

 

创建一个有上限的线程池：

public class test1 {
    public static void main(String[] args)  {
        //创建线程池对象
      ExecutorService poll= Executors.newFixedThreadPool(2);
      //提交任务
        poll.submit(new MyRunnable());
        poll.submit(new MyRunnable());
        poll.submit(new MyRunnable());
        //线程池一般不会关闭
    }
    }

自定义线程池

系统先会创建服务于任务1、2、3的线程1、2、3；再将任务4、5、6拿去排队； 再调用临时线程服务于任务7、8、9；任务10会触发任务拒绝策略。

任务拒绝策略

创建自定义线程池：

public class test1 {
    public static void main(String[] args)  {
        //自定义线程池
        ThreadPoolExecutor pool=new ThreadPoolExecutor(
                3,//核心线程的数量
                6,//最大线程数
                60,//空闲线程最大存活时间
                TimeUnit.SECONDS,//时间单位
                new ArrayBlockingQueue<>(3),//任务队列，相当于阻塞队列
                Executors.defaultThreadFactory(),//创建线程工厂:线程池如何获取到一个线程
                new ThreadPoolExecutor.AbortPolicy()//任务拒绝策略
        );
    }
    }

线程池多大合适

 

 

多喝烫水__
关注
  • 10
    点赞
  • 踩
  • 10
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
多线程.zip
09-08
本资源包“多线程.zip”提供了丰富的学习材料，包括源码和书籍，旨在帮助开发者深入理解并掌握多线程编程。 《C#多线程编程实战》是一本专注于C#语言的多线程技术专著，中文完整版的提供，使得国内开发者能够更加...
多线程 .zip
11-23
本压缩包文件“多线程.zip”可能包含一系列关于多线程编程的资源，包括文档、代码示例或其他相关材料。 多线程的原理是操作系统将CPU时间片分配给各个线程，使得它们看起来是并行执行的，实际上是在快速切换之间。...
多线程 join 方法
Gonelin的博客
12-22 6156
多线程 join 方法 1.前言 本节对 join 方法进行深入的剖析，主要内容点如下： 了解 join 方法的作用，初步的理解 join 方法的使用带来的效果是学习本节内容的基础； 了解 join 方法异常处理，我们在使用 join 方法是，需要对 join 方法进行有效的异常处理； 通过匿名内部类创建Thread 是我们本节代码示例所使用的的方式，对这种方式的掌握在后续工作中非常重要； 掌握 join 方法如何使用，这是本节的重点内容，也是本节的核心内容； 掌握带参数的 join 方法使用，在后续开发
Java多线程超详解
热门推荐
weixin_44797490的博客
06-11 14万+
引言 随着计算机的配置越来越高，我们需要将进程进一步优化，细分为线程，充分提高图形化界面的多线程的开发。这就要求对线程的掌握很彻底。 那么话不多说，今天本帅将记录自己线程的学习。 线程的相关API //获取当前线程的名字 Thread.currentThread().getName() 1.start():1.启动当前线程2.调用线程中的run方法 2.run():通常需要重写Thread类中的此...
callable多线程future.get()方法
weixin_42440765的博客
07-19 4876
callable多线程future.get()方法能获取到当前线程的执行结果，但是会阻塞当前线程，即当前线程执行结束获取到结果后才会继续执行下一个线程，解决方法： 创建一个List数组存储funture，在所有线程执行以后遍历list获取结果。 int count = 0; List<Future<Integer>> res = new ArrayList<>(); ExecutorService executorService = Executors.newCached
C#高级--多线程详解
李宥的博客
10-03 4万+
C#高级–多线程详解 零、文章目录 一、什么是多线程 1、进程 当一个程序开始运行时，它就是一个进程，进程包括运行中的程序和程序所使用到的内存和系统资源。 而一个进程又是由多个线程所组成的。 2、线程 线程是程序中的一个执行流，每个线程都有自己的专有寄存器(栈指针、程序计数器等)，但代码区是共享的，即不同的线程可以执行同样的函数。 3、句柄 句柄是Windows系统中对象或实例的标识，这些对象包括模块、应用程序实例、窗口、控制、位图、GDI对象、资源、文件等。 4、多线程 （1）多线程概念 多线程是指程序中
Java多线程实战-实现多线程文件下载，支持断点续传、日志记录等功能
qq_35716689的博客
03-10 12万+
本文将介绍如何通过Java来实现一个多线程下载器。作者：牵着猫散步的鼠鼠
万字图解Java多线程
qq_35598736的博客
09-06 5万+
前言 java多线程我个人觉得是javaSe中最难的一部分，我以前也是感觉学会了，但是真正有多线程的需求却不知道怎么下手，实际上还是对多线程这块知识了解不深刻，不知道多线程api的应用场景，不知道多线程的运行流程等等，本篇文章将使用实例+图解+源码的方式来解析java多线程。 文章篇幅较长，大家也可以有选择的看具体章节，建议多线程的代码全部手敲，永远不要相信你看到的结论，自己编码后运行出来的，才是自己的。 什么是java多线程? 进程与线程 进程 当一个程序被运行，就开启了一个进程， 比如启动了qq，w.
C# 多线程详细讲解
fenglearning的博客
05-27 2万+
C#多线程 一、基本概念 1、进程 首先打开任务管理器，查看当前运行的进程： 从任务管理器里面可以看到当前所有正在运行的进程。那么究竟什么是进程呢？ 进程（Process）是Windows系统中的一个基本概念，它包含着一个运行程序所需要的资源。一个正在运行的应用程序在操作系统中被视为一个进程，进程可以包括一个或多个线程。 线程是操作系统分配处理器时间的基本单元，在进程中可以有多个线程同时执行代码。进程之间是相对独立的，一个进程无法访问另一个进程的数据（除非利用分布式计算方式）， 一个进程运
【多线程】线程池
王佑辉的博客
04-04 4631
3.keepAliveTime：多余的空闲线程的存活时间，当前线程池数量超过corePoolSize时，当空闲时间达到keepAliveTime时，多余空闲线程会被销毁直到只剩下corePoolSize个线程为止。7.handler：拒绝策略，表示当队列满了并且工作线程-大于等于线程池的数量最大线程数（maxinumPoolSize）时如何来拒绝请求执行的runnable的策略。6.threadFactory：表示生成线程池中工作线程的线程工厂，用于创建线程一般用默认的即可。
一文详解C++多线程
非晚非晚的博客
04-25 7万+
传统的C++（C++11之前）中并没有引入线程这个概念，在C++11出来之前，如果我们想要在C++中实现多线程，需要借助操作系统平台提供的API，比如Linux的<pthread.h>，或者windows下的<windows.h> 。C++11提供了语言层面上的多线程，包含在头文件<thread>中。它解决了跨平台的问题，提供了管理线程、保护共享数据、线程间同步操作、原子操作等类。C++11 新标准中引入了5个头文件来支持多线程编程，如下图所示：
python实现多线程
qq_35778860的博客
09-11 6275
本文转载于上面的链接. 文章目录1 线程基本概念1.1 线程是什么？1.2 线程和进程关系？2 Python线程模块3 线程间同步4 线程池4.1 传统多线程问题？4.2 线程池基本原理：5 协程5.2 Send来了6. python 进行并发编程6.1 使用asyncio6.2 使用async/await7 小结 1 线程基本概念 1.1 线程是什么？ 线程是指进程内的一个执行单元...
API多线程.rar
04-04
当我们谈论"API多线程"时，这通常涉及到在编程中使用API来实现多线程操作。 1. API的理解与应用： API是由操作系统或库提供的接口，开发人员可以通过调用这些接口来实现特定的功能，如文件操作、网络通信等。...
03. 多线程.vep
03-20
0.3.Net Core 多线程 深入分析。大黄蜂云课堂播放器观看。
多线程.rar
09-15
本资料"多线程.rar"提供了关于多线程的理论知识讲解和实际示例，旨在帮助你深入理解和应用这一技术。 **多线程理论知识** 1. **线程定义**：线程是操作系统分配CPU时间的基本单元，一个进程中可以包含一个或多个...
10.javaSE基础_JDBC编译程序(Driver+Statement+Connection+mysql数据库连接)
最新发布
m0_61086522的博客
07-02 888
JDBC是的缩写。它是Sun的Javasoft公司制定的Java数据库连接技术，是一套标准接口java.sql包中提供了JDBC API,通过它连接到各种数据库系统，编写访问数据库的程序。JDBC API不能直接访问数据库，它依赖于数据库厂商提供的JDBC Driver（JDBC驱动程序）
配置系统PATH环境变量
weixin_44626980的博客
06-29 630
PATH环境变量在操作系统中起着非常重要的作用，特别是在命令行或脚本中执行程序时，系统会根据PATH环境变量中定义的路径查找可执行文件。当用户在命令行或脚本中输入一个命令时，系统会根据PATH环境变量中定义的路径依次查找对应的可执行文件，如果找到则执行。本文详细介绍了如何配置系统的PATH环境变量，包括在Windows和Linux系统中的操作步骤。在Linux系统中，可以通过编辑shell配置文件来配置PATH环境变量，常用的shell配置文件包括.bashrc、.bash_profile等。
【C#】找不到属性集方法。get只读属性用了反射设置setValue肯定报错
小5聊的博客
06-26 1812
找不到属性集方法。get只读属性用了反射设置setValue肯定报错
基于weixin小程序智慧物业系统的设计
ing65768的博客
06-27 463
管理员账户功能包括：系统首页，个人中心，管理员管理，用户管理，员工管理，房屋管理，缴费管理，车位管理，报修管理。主要技术：Java,Spring,mybatis,mysql,jquery,html。工作人员账号功能包括：系统首页，维修管理，维修指派，公告管理，轮播图信息。服务器：SpringBoot自带 apache tomcat。JDK版本：Java JDK1.8。数据库可视化工具： navicat。数据库版本： mysql5.7。开发工具：IDEA(推荐)开发系统：Windows。
java多线程.join
11-18
下面是一个Java多线程.join()的例子： ```java public class JoinTest implements Runnable { @Override public void run() { for (int i = 0; i ; i++) { System.out.println("线程VIP来了" + i); } } ...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值