java多线程创建实例怎么做 java多线程两种创建方式

一、通过继承Thread类的方式创建线程
1.继承Thread类
2.重写run()方法
3.创建对象通过start()方法启动线程

public class Demo01_多线程创建方式一 {
	public static void main(String[] args) {
		A a = new A();
		B b = new B();
		//a.run();要实现并发，不能用run()
		a.start();//启动线程，自动调用run()方法
		b.start();
	}
}

class A extends Thread{
	//重写方法，不能比父类抛出更多的异常，权限修饰符大，返回值小，异常少
	//2.重写run()方法
	public void run(){
		for (int i = 0; i <=30; i=i+1) {
			try {
				sleep(1000);
			} catch (InterruptedException e) {
				// TODO Auto-generated catch block
				e.printStackTrace();
			}
			System.out.println("A###"+i);
		}
	}
}
class B extends Thread{
	public void run(){
		for (int i = 1; i <30 ; i=i+2) {
			try {
				sleep(500);
			} catch (InterruptedException e) {
				// TODO Auto-generated catch block
				e.printStackTrace();
			}
			System.out.println("B***"+i);
		}
	}
	
}

二、实现Runnable接口的方式创建线程
1、实现Runnable接口
2.重写run()方法
3、将新建对象的形参传入，新建Thread类对象的构造方法中
4.通过stat()方法启动线程

public class Demo02_多线程创建方式二 {
	public static void main(String[] args) {
		Aa aa = new Aa();
		Ba ba =new Ba();
		//3、将新建对象的形参传入，新建Thread类的构造方法中
		Thread t1 = new Thread(aa);
		Thread t2 = new Thread(ba);
		//4.通过stat()方法启动线程
		t1.start();
		t2.start();
		
	}
}

//1、实现Runnable接口
class Aa implements Runnable{
	//2.重写run()方法
	public void run() {
		for (int i = 0; i <=30; i++) {
			try {
				Thread.sleep(300);
			} catch (InterruptedException e) {
				// TODO Auto-generated catch block
				e.printStackTrace();
			}
			System.out.println("Aa&&&"+i);
		}
	}
	
}
class Ba implements Runnable{

	@Override
	public void run() {
		for (int i = 0; i <=30; i++) {
			try {
				Thread.sleep(300);
			} catch (InterruptedException e) {
				// TODO Auto-generated catch block
				e.printStackTrace();
			}
			System.out.println("Ba%%%"+i);
		}
	}
	
}

三、使用Callable接口创建对象
步骤：
1.实现Callable接口
2.重写call()方法
3.将创建的对象引用传入，新建的FutureTask对象中
4.通过new Thread()传入新引用启动线程
5.通过FutureTask的get()方法获取返回值

与使用Runnable相比，功能更强大：
1.相比run方法，可以有返回值
2.方法可以抛出异常
3.支持泛型的返回值
4.需要借助FutureTask类，比如获取返回结果

import java.util.concurrent.Callable;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.FutureTask;
//1.实现Callable接口
class BB implements Callable<Integer>{
	//2.重写call()方法
	public Integer call() throws Exception {
		int sum = 0;
		for (int i = 0; i <=50; i++) {
			sum = i+sum;
			System.out.println(i);
		}
		return sum;
	}
}
public class Demo3_多线程创建方式三 {
	public static void main(String[] args) {
		BB bb = new BB();
		//3.将创建的对象引用传入，新建的FutureTask对象中
		FutureTask<Integer> f = new FutureTask<>(bb);
		//4.通过new Thread()传入新引用启动线程
		new Thread(f).start();
		//5.通过FutureTask的get()方法获取返回值
		try {
			f.get();
			System.out.println("返回值为"+f.get());
		} catch (InterruptedException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		} catch (ExecutionException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		}
		
	}
}

四、通过线程池创建线程
步骤：
1.提供指定线程数的线程池
2.执行指定线程的操作。需要提供实现Runnable接口或者Callable接口
3.关闭线程池

好处：
1.提高了相应速度（减少了创建线程的时间）
2.降低了资源消耗（重复利用线程池中的线程不需要每次都创建）
3.便于线程管理

class CC implements Runnable{

	public void run() {
		for (int i = 0; i <100; i++) {
			if(i%2==0){
				System.out.println(i);
			}
		}
	}
	
}
public class Demo4_多线程创建方式四 {

	public static void main(String[] args) {
		//1.提供指定线程数的线程池
		ExecutorService  service = Executors.newFixedThreadPool(10);
		//2.执行指定线程的操作。需要提供实现Runnable接口或者Callable接口
		service.execute(new CC());//适合于Runnable接口
		//service.submit();//适合于Callable接口
		//3.关闭线程池
		service.shutdown();
	}

}