「javaworker类」java常见类
本篇文章给大家谈谈javaworker类，以及java常见类对应的知识点，希望对各位有所帮助，不要忘了收藏本站喔。
本文目录一览：
- 1、怎么知道java多线程都已经运行结束
- 2、java编程 声明一个抽象Person 类。Student 类，Worker类分别继承Person。
- 3、Java多线程MasterWorker模式如何在高并发情况下优化
- 4、在java中，类Worker是类Person的子类，Worker的构造方法中有一句“super()"，该语句（ ）
怎么知道java多线程都已经运行结束
一、使用java.util.concurrent.CountDownLatch
Java的util.concurrent包里面的CountDownLatch其实可以把它看作一个计数器，只不过这个计数器的操作是原子操作，同时只能有一个线程去操作这个计数器，也就是同时只能有一个线程去减这个计数器里面的值。
你可以向CountDownLatch对象设置一个初始的数字作为计数值，任何调用这个对象上的await()方法都会阻塞，直到这个计数器的计数值被其他的线程减为0为止。
CountDownLatch的一个非常典型的应用场景是：有一个任务想要往下执行，但必须要等到其他的任务执行完毕后才可以继续往下执行。假如我们这
个想要继续往下执行的任务调用一个CountDownLatch对象的await()方法，其他的任务执行完自己的任务后调用同一个
CountDownLatch对象上的countDown()方法，这个调用await()方法的任务将一直阻塞等待，直到这个
CountDownLatch对象的计数值减到0为止。
举个例子，有三个工人在为老板干活，这个老板有一个习惯，就是当三个工人把一天的活都
干完了的时候，他就来检查所有工人所干的活。记住这个条件：三个工人先全部干完活，老板才检查。所以在这里用Java代码设计两个类，Worker代表工
人，Boss代表老板，具体的代码实现如下：
Worker类（单独的线程）：
package cn.edu.bupt.thread.threadnotify;
import java.util.Random;
import java.util.concurrent.CountDownLatch;
import java.util.concurrent.TimeUnit;
public class Worker implements Runnable
{
private CountDownLatch downLatch;
private String name;
public Worker(CountDownLatch downLatch, String name)
{
this.downLatch = downLatch;
this.name = name;
}
@Override
public void run()
{
this.doWork();
try
{
TimeUnit.SECONDS.sleep(new Random().nextInt(10));
}
catch (InterruptedException ie)
{
}
System.out.println(this.name + "活干完了！");
this.downLatch.countDown();
}
private void doWork()
{
System.out.println(this.name + "正在干活...");
}
}
Boss类（单独的线程）：
package cn.edu.bupt.thread.threadnotify;
import java.util.concurrent.CountDownLatch;
public class Boss implements Runnable
{
private CountDownLatch downLatch;
public Boss(CountDownLatch downLatch)
{
this.downLatch = downLatch;
}
@Override
public void run()
{
System.out.println("老板正在等所有的工人干完活......");
try
{
this.downLatch.await();
}
catch (InterruptedException e)
{
}
System.out.println("工人活都干完了，老板开始检查了！");
}
}
Main：
package cn.edu.bupt.thread.threadnotify;
import java.util.concurrent.CountDownLatch;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
public class CountDownLatchDemo
{
public static void main(String[] args)
{
ExecutorService executor = Executors.newCachedThreadPool();
CountDownLatch latch = new CountDownLatch(3);
Worker w1 = new Worker(latch, "张三");
Worker w2 = new Worker(latch, "李四");
Worker w3 = new Worker(latch, "王二");
Boss boss = new Boss(latch);
executor.execute(boss);
executor.execute(w3);
executor.execute(w2);
executor.execute(w1);
executor.shutdown();
}
}
上例中的的ExecutorService接口和Executors类的作用类似于new Thread(Runnable r).start()的作用，就是启动一个新的线程。
java编程 声明一个抽象Person 类。Student 类，Worker类分别继承Person。
子类要实现抽象父类的方法
public class Student extends Person{
//1.学生特有属性:学生学号
public int studentNum;
//2.无参构造方法
public Student(){
}
//有参构造方法
public Student(String name,String gender,int age,int studentNum){
//父类有的属性，通过super关键字获得即可
super();
this.studentNum=studentNum;
}
//3.要实例化抽象父类的行为方法
public void talk(){
System.out.println("我要好好学习java编程");
}
//set and get 方法自己添加
}
自己再写个测试类，带main函数的进行测试
Java多线程MasterWorker模式如何在高并发情况下优化
你说的Master指的是java的线程池吧，我之前做过一个项目，因为项目在内网拿不出来，我给你说一下我那次的经验。
几个关键点：
1、java线程池：使用java提供的ThreadPoolExecutor类构造主池，再构造一个辅池（辅池的作用在于当主池进入拒绝策略的时候，可以启动辅池，帮助主池分担一部分线程，或者在主池shutdown的瞬间又有任务进来，也会走到拒绝策略，此时可以启动辅池处理这些线程，一般情况下辅池不会启动），排队策略使用LinkedBlockingQueue队列。
2、单例模式：利用spring的IOC容器的单例性，每次取线程池时，从IOC容器中注入。创建一个组件类BatPool（spring组件默认为单例），里面再使用单例模式创建线程池，单例中的单例，保证单例性：
@Component
class BatPool{
private ThreadPoolExecutor mainPool;
ThreadPoolExecutor create(){
if(mainPool== null){
retrun new ThreadPoolExecutor();
}else{
retrun mainPool;
}
...
}
业务中：
@Autowired
BatPool batPool;
ThreadPoolExecutor pool = batPool.create();
...
线程池的配置你自己参考网上吧
这样在业务中，每次取到的池都是同一个池，不会多次创建。
如果你没有使用spring的话，我再想想办法怎么实现全局的单例模式
在java中，类Worker是类Person的子类，Worker的构造方法中有一句“super()"，该语句（ ）
是C
因为构造方法里的super（）那肯定是调用父类的构造函数。
类Worker是类Person的子类。说明Worker的父类是Person。所以调用的是person的构造函数
关于javaworker类和java常见类的介绍到此就结束了，不知道你从中找到你需要的信息了吗 ？如果你还想了解更多这方面的信息，记得收藏关注本站。
发布于：2022-11-30，除非注明，否则均为原创文章，转载请注明出处。