hilo
Los hilos también son procesos livianos. Un proceso de control secuencial en un programa y también la unidad de programación básica de la CPU. Un proceso se compone de múltiples subprocesos, que completan diferentes tareas entre sí y se ejecutan alternativamente para convertirse en un subproceso múltiple.
Método de hilo creado
~ El primer tipo, heredar Thread
La clase Thread es esencialmente una instancia que implementa la interfaz Runnable y representa una instancia de un subproceso que anula el método de ejecución para completar la tarea.
public class ThreadTest {
public static void main(String[] args) {
MyThread mt = new MyThread();
MyThread2 mt2 = new MyThread2();
//开启线程
mt.start();
mt2.start();
System.out.println("程序结束");
}
}
//线程1继承Thread
class MyThread extends Thread{
public void run() {
for(int i=0 ;i<50;i++) {
System.out.println("myThread:"+i);
}
}
}
//线程2继承Thread
class MyThread2 extends Thread{
public void run() {
for(int i=0;i<50;i++) {
System.out.println("myThread2:"+i);
}
}
}
~ La segunda forma es implementar la interfaz Runnable.
注：如果自己的类已经 extends 另一个类，就无法直接 extends Thread，此时，可以实现一个 Runnable 接口
package ThreadMost;
public class RunnableTest {
public static void main(String[] args) {
//创建实现类对象
MyRunnable mr = new MyRunnable();
MyRunnable2 mr2 = new MyRunnable2();
//将任务交给线程
Thread t1 = new Thread(mr);
Thread t2 = new Thread(mr2);
//开启线程
t1.start();
t2.start();
System.out.println("程序结束");
}
}
//线程1实现Runnable接口
class MyRunnable implements Runnable{
@Override
public void run() {
// TODO Auto-generated method stub
for(int i =1;i<50;i++) {
System.out.println("MyRunnable:"+i);
}
}
}
//线程2实现Runnable接口
class MyRunnable2 implements Runnable{
@Override
public void run() {
// TODO Auto-generated method stub
for(int i =1;i<50;i++) {
System.out.println("MyRunnable2:"+i);
}
}
}
~ La tercera forma es implementar la interfaz invocable.
Tiene un valor de retorno de hilo y puede declarar excepciones.
注：有返回值的任务必须实现 Callable 接口，类似的，无返回值的任务必须 Runnable 接口
public class CallableTest {
public static void main(String[] args) throws InterruptedException, ExecutionException {
//创建一个线程池
ExecutorService es = Executors.newFixedThreadPool(3);
Callable<Integer> cb1 = new CallTest();
Callable<Integer> cb2 = new CallTest();
// 执行任务并获取 Future 对象
Future<Integer> s1 = es.submit(cb1);
Future<Integer> s2 = es.submit(cb2);
// 关闭线程池
pool.shutdown();
// 获取所有并发任务的运行结果
Integer i1 = s1.get();
Integer i2 = s1.get();
System.out.println(i1+"\t"+i2);
}
}
class CallTest implements Callable<Integer>{
//实现接口重写方法
@Override
public Integer call() throws Exception {
// TODO Auto-generated method stub
int sum = 0;
for(int i=0;i<100;i++) {
System.out.println(Thread.currentThread().getName()+"："+i);
sum +=i;
}
return sum;
}
}
- La interfaz Future
recibe de forma asincrónica el resultado de estado devuelto por ExecutorService.submit(), que incluye el valor de retorno de call().
Esperando resultados de procesamiento asincrónico en Future en modo de bloqueo .get()
~ La cuarta forma, basada en el grupo de subprocesos
Los hilos y las conexiones de bases de datos son recursos muy valiosos.
Entonces es un gran desperdicio de recursos crearlo cada vez que es necesario y destruirlo cada vez que no es necesario . Luego podemos usar la estrategia de almacenamiento en caché, es decir, usar el grupo de subprocesos.
public class RunnableTest {
public static void main(String[] args) {
// 创建线程池
ExecutorService threadPool = Executors.newFixedThreadPool(10);
while(true) {
threadPool.execute(new Runnable() {
// 提交多个线程任务，并执行
@Override
public void run() {
System.out.println(Thread.currentThread().getName() + " is running ..");
try {
Thread.sleep(3000);
} catch (InterruptedException e) {
e.printStackTrace();
}
}
});
}
}
}
Espero que esto te ayude
~感谢您的光临~
