Java多线程-线程的创建
Java多线程-线程的创建
方式一：继承于Thread类
1.创建一个继承于Thread类的子类
2.重写Thread类的run()方法;（线程实现的功能）
3.创建Thread子类的对象
4.通过Thread子类对象调用start()方法;
/** *多线程的创建：方式一：继承于Thread类 * 1.创建一个继承于Thread类的子类 * 2.重写Thread类的run()方法;（线程实现的功能） * 3.创建Thread子类的对象 * 4.通过Thread子类对象调用start(); * *<p> *例子 遍历100以内所有的偶数 * @author orz * * */ //1.创建一个继承于Thread类的子类 class MyThread extends Thread{ //2.重写Thread类的run()方法 @Override public void run() { for (int i = 0; i < 100; i++) { if(i%2==0) { System.out.println(Thread.currentThread().getName()+":"+i); } } } } /** * @author orz */ public class ThreadTest { public static void main(String[] args) { //3.创建Thread子类的对象 MyThread t=new MyThread(); //4.通过Thread子类对象调用start()方法 t.start(); for (int i = 0; i <100 ; i++) { System.out.println("main*****"+i); } } }
方式二：实现Runnable接口
1.创建一个实现了Runnable接口的类
2.实现类去实现Runnable中的抽象方法：run();
3.创建实现类的对象
4.将此实现类对象作为参数传递到Thread类的构造器中，创建Thread类的对象
5.通过Thread类对象调用start()方法
/** * 创建多线程的方式二：实现Runnable接口 * 1.创建一个实现了Runnable接口的类 * 2.实现类去实现Runnable中的抽象方法：run(); * 3.创建实现类的对象 * 4.将此实现类对象作为参数传递到Thread类的构造器中，创建Thread类的对象 * 5.通过Thread类对象调用start()方法 * * * 比较创建线程的两种方式（继承Thread、实现Runnable接口） * 开发中:优先选择实现Runnable接口方式 * 原因： * 1.实现的方式没有类的单继承性的局限 * 2.实现的方式更适合来处理多个线程有共享数据的情况 * * *联系： * * * @author orz */ //1.创建一个实现了Runable接口的类 class MThread implements Runnable { //2.实现类去实现Runable中的抽象方法：run(); @Override public void run() { for (int i = 0; i <100 ; i++) { System.out.println(i); } } } public class ThreadTest1 { public static void main(String[] args) { //3.创建实现类的对象 MThread m=new MThread(); /*4.将此对象作为参数传递到Thread类的构造器中，创建Thread类的对象*/ Thread t1=new Thread(m); //5.通过Thread类对象调用start() t1.start(); } }
方式三：实现Callable接口
1.创建一个实现Callable接口的实现类
2.实现call()方法。（将此线程需要执行的操作声明在call()中）
3.创建Callable接口实现类对象
4.将此Callable接口实现类对象作为参数传递到FutureTask()构造器中，创建FutureTask的对象
5.将FutureTask的对象作为参数传递到Thread类的构造器中，创建Thread对象，并调用start()方法
补充：如果需要可以获取Callable中call()方法的返回值；调用FutureTask对象的get()方法
/** * 创建线程的方式三：实现Callable接口---jdk5.0 * * * 1.创建一个实现Callable的实现类 * 2.实现call方法，将此线程需要执行的操作声明在call()中 * 3.创建Callable接口实现类对象 * 4.将此Callable接口实现类对象作为参数传递到FutureTask()构造器中，创建FutureTask的对象 * 5.将FutureTask的对象作为参数传递到Thread类的构造器中，创建Thread对象，并调用start()方法 * 补充：获取Callable中call()方法的返回值：调用FutureTask对象的get()方法 * @author orz */ public class ThreadNew { public static void main(String[] args) {
//3.创建Callable实现类对象 NumThread n=new NumThread();
//4.将此实现类对象作为参数传到FutureTask()构造器中，创建FutureTask对象 FutureTask t=new FutureTask(n);
//将FutuTask对象作为参数传到Thread类的构造器中，创建Thread类对象，并调用start()方法 new Thread(t).start(); try { /*get()返回值即为FutureTask构造器参数Callable实现类重写的call()返回值*/ Object sum= t.get(); System.out.println("总和为："+sum); } catch (InterruptedException e) { e.printStackTrace(); } catch (ExecutionException e) { e.printStackTrace(); } } }
//1.创建一个实现了Callable接口的对象 class NumThread implements Callable {
//2.实现call()方法 @Override public Object call() throws Exception { int sum=0; for (int i = 0; i <=100 ; i++) { if(i%2==0) { System.out.println(i); sum=sum+i; } } return sum; } }
方式四：使用线程池
1.提供指定线程数量的线程池
2.执行指定的线程的操作。需要提供Runnable接口或者Callable接口实现类对象
3.关闭线程池
/** * 创建线程的方式四：使用线程池 * 1.提供指定线程数量的线程池 * 2.执行指定的线程的操作。需要提供Runnable接口或者Callable接口实现类对象 * 3.关闭线程池 * 好处： * 1.提高响应速度（减少了新线程创建时间） * 2.降低资源消耗（重复利用线程池的线程，不需要每次都创建） * 3.便于线程管理 * @author orz */ public class ThreadPool { public static void main(String[] args) {
//本例子使用了实现Runnable接口的类对象 //1.提供指定线程数量的线程池 ExecutorService service = Executors.newFixedThreadPool(10); /* ThreadPoolExecutor service= (ThreadPoolExecutor) service; //设置线程池的属性 service.setCorePoolSize(15);*/ /*2.执行指定的线程的操作。需要提供Runnable接口或者Callable接口实现类对象*/ //execute()适合使用于Runnable service.execute(new NumberThread()); service.execute(new NumberThread1()); //submit()适合使用于Callable //executorService.submit(); //3.关闭线程池 service.shutdown(); } } class NumberThread implements Runnable { @Override public void run() { for (int i = 0; i <=100 ; i++) { if(i%2==0) { System.out.println(Thread.currentThread().getName()+"："+i); } } } } class NumberThread1 implements Runnable { @Override public void run() { for (int i = 0; i <=100 ; i++) { if(i%2!=0) { System.out.println(Thread.currentThread().getName()+"："+i); } } } }
import java.util.concurrent.*; /** * 本例子使用了实现Callable接口的类对象 * @author orz */ public class PoolTest { public static void main(String[] args) { //1.提供指定线程数量的线程池 ExecutorService service= Executors.newFixedThreadPool(10); Object o = null; try { /*2.执行指定的线程的操作。提供Callable接口实现类对象*/ //获取Callable中call()方法的返回值 o = service.submit(new MyThread()).get(); System.out.println("sum="+o); } catch (InterruptedException e) { e.printStackTrace(); } catch (ExecutionException e) { e.printStackTrace(); } //3.关闭线程池 service.shutdown(); } } //创建一个实现Callable的实现类 class MyThread implements Callable { int sum=0; //实现call方法 @Override public Object call() throws Exception { for (int i = 0; i <100 ; i++) { if(i%2==0) { sum=sum+i; System.out.println(Thread.currentThread().getName()+":"+i); } } return sum; } }
