5.27多线程中的线程组与线程池

线程组

package org.westos.线程组线程池博客练习;
/**
 * 线程组:ThreadGroup
 * 构造方法:
 * 		public ThreadGroup(String name)构造一个新线程组
 * 方法:
 * 		public final String getName()返回此线程组的名称。 
 * 可以通过Thread类的getThreadGroup返回一个线程组
 * 		public final ThreadGroup getThreadGroup()返回该线程所属的线程组。默认为主线程main
 * */
public class Text1 {
	public static void main(String[] args) {
		MyThread1 my1 = new MyThread1();
		Thread t1 = new Thread(my1, "线程一");
		Thread t2 = new Thread(my1, "线程二");
		ThreadGroup tg1 = t1.getThreadGroup();
		ThreadGroup tg2 = t2.getThreadGroup();
		System.out.println(tg1.getName());//输出main,线程组默认名称为主线程main
		System.out.println(tg2.getName());//输出main,线程组默认名称为主线程main
		System.out.println(Thread.currentThread().getThreadGroup().getName());//输出main,线程组默认名称为主线程main
		//如何设置一个线程组名称
		ThreadGroup tg3 = new ThreadGroup("我是一个线程组");
		Thread t3 = new Thread(tg3, t2, "线程三");
		System.out.println(tg3.getName());
		System.out.println(t3.getThreadGroup().getName());
	}
}

package org.westos.线程组线程池博客练习;

public class MyThread1 implements Runnable {

	@Override
	public void run() {
		for(int i = 0;i<100;i++) {
			System.out.println(Thread.currentThread().getName()+"----"+i);
		}
	}

}

线程池

package org.westos.线程组线程池博客练习;

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

/**
 * 线程池:ThreadPool
 * 优点:
 * 		1.节约成本
 * 		2.线程池可以重复利用,线程池中的线程被调用执行完毕之后,会返回线程池中等待再次被调用
 * 线程池在Exceutos工厂类提供
 * 	方法:
 * 		public static ExecutorService newFixedThreadPool(int nThreads)
 * 			创建一个可重用固定线程数的线程池，以共享的无界队列方式来运行这些线程	
 * 	ExecutorService:可以执行异步任务
 *		创建一个线程池,执行接口中的方法
 *		提交:Future<?> submit(Runnable task)
 *		<T> Future<T> submit(Callable<T> task)提交一个返回值的任务用于执行，返回一个表示任务的未决结果的 Future	
 * */
public class Text2 {
	public static void main(String[] args) {
		
		//创建一个线程池
		ExecutorService pool = Executors.newFixedThreadPool(2);
		//提交和Runnable接口的方法或者Callable(提交任务)
		MyThread1 my = new MyThread1();
		pool.submit(my);
		pool.submit(new MyThread1());
		//关闭线程池
		pool.shutdown();
		//将会输出	pool-1-thread----2 :线程池-池数-线程类对象的描述-编号(从1开始)
	}
}

多线程实现第三种

package org.westos.线程组线程池博客练习;

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

/**
 * 多线程的实现方式第三种:
 *  	前提:自定义类实现Callable接口
 *		1)创建线程池对象: Executors 里面的那个方法,返回的是ExecutorsService
 *		2) 然后调用ExecutorsService里面的提交任务的方法:
 *		<T> Future<T> submit(Callable<T> task)提交一个返回值的任务用于执行
 *		3)关闭线程池
 * */
public class Text3 {
	public static void main(String[] args) {
		//创建一个线程池对象
		ExecutorService pool = Executors.newFixedThreadPool(2);
		//提交任务
		pool.submit(new MyCallable());
		pool.submit(new MyCallable());
		//关闭线程池
		pool.shutdown();
	}
}

package org.westos.线程组线程池博客练习;

import java.util.concurrent.Callable;

public class MyCallable implements Callable {

	@Override
	public Object call() throws Exception {
		for(int i= 0;i<100;i++) {
			System.out.println(Thread.currentThread().getName());
		}
		return null;
	}

}

含有返回值得Callable

package org.westos.线程组线程池博客练习;

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

//含有返回值的Callable
public class Text4 {
	public static void main(String[] args) throws InterruptedException, ExecutionException {
		//创建线程池对象
		ExecutorService pool = Executors.newFixedThreadPool(2);
		//提交任务
		Future<Integer> i1 = pool.submit(new MyCallable2(100));
		Future<Integer> i2 = pool.submit(new MyCallable2(200));
		//获取结果
		System.out.println("1~100的和为"+i1.get());
		System.out.println("1~200的和为"+i2.get());
		//关闭线程池
		pool.shutdown();
	}
}

package org.westos.线程组线程池博客练习;

import java.util.concurrent.Callable;

public class MyCallable2 implements Callable<Integer> {
	private int num;
	public MyCallable2(int num) {
		this.num = num;
	}
	@Override
	public Integer call() throws Exception {
		int sum = 0;
		for(int i=0;i<=num;i++) {
			sum = sum+i;
		}
		return sum;
	}

}