Java并发学习----创建线程的多种方式

偏执的太偏执、 2022-05-17 00:34 189阅读 0赞

# 创建线程的多种方式 #

1.  继承Thread类
2.  实现Runnable接口
3.  匿名内部类的方式
4.  带返回值的方式
5.  定时器
6.  线程池的实现
7.  Lambda表达式的实现

一、继承Thread类

public class Demo1 extends Thread{
    	public Demo1(String name) {
    		super(name);
    	}
    	@Override
    	public void run() {
    		while(!interrupted()) {
    			System.out.println(getName()+"线程启动了...");
    			/*try {
    				Thread.sleep(2000);
    			} catch (InterruptedException e) {
    				e.printStackTrace();
    			}*/
    		}
    			
    		//super.run();
    	}
    	
    	public static void main(String[] args) {
    		Demo1 d1 = new Demo1("first");
    		Demo1 d2 = new Demo1("second");
    		
    		//true设置为守护线程，false设置为用户线程，如果不设置 属性，默认为用户线程。
    		//d1.setDaemon(true);
    		//d2.setDaemon(true);
    		d1.start();
    		d2.start();
    		try {
    			Thread.sleep(1);
    		} catch (InterruptedException e) {
    			e.printStackTrace();
    		}
    		System.out.println("主线程启动了");	
    		d1.interrupt();
    		d2.interrupt();
    	}
    }

二、实现Runnable接口

public class Demo2 implements Runnable{
    	
    	@Override
    	public void run() {
    		while(true) {
    			System.out.println("线程执行了...");
    		}
    	}
    	
    	public static void main(String[] args) {
    		
    		Thread td1 = new Thread(new Demo2());
    		td1.start();
    	}
    }

三、匿名内部类的方式

public class Demo2 {
    	
    
    	public static void main(String[] args) {
    		new Thread() {
    			public void run() {
    				System.out.println("匿名内部类线程1执行了..");
    			}
    		}.start();
    		
    		new Thread(new Runnable() {
    			@Override
    			public void run() {
    				System.out.println("匿名内部类线程2执行了..");
    			}
    		}).start();
    		
    	//下面这种方式打印的是sub，重写runnable接口和重写子类同时写的话，执行的是子类的线程
    		new Thread(new Runnable() {
    			@Override
    			public void run() {
    				System.out.println("runnable");
    			}
    		}) {
    			public void run() {
    				System.out.println("sub");
    			}
    		}.start();
    	}
    }

四、带返回值的方式

import java.util.concurrent.Callable;
    import java.util.concurrent.FutureTask;
    
    public class Demo4 implements Callable<Integer>{
    
    	@Override
    	public Integer call() throws Exception {
    		System.out.println("正在进行计算..");
    		Thread.sleep(1000);
    		return 1;
    	}
    	
    	public static void main(String[] args) throws  Exception {
    		
    		Demo4 d = new Demo4();
    		FutureTask<Integer> task = new FutureTask<>(d);
    		Thread td = new Thread(task);
    		td.start();
    		
    		System.out.println("我先干点别的");
    		
    		Integer result = task.get();
    		System.out.println("线程执行结果为：" + result);
    	}
    }

输出结果：  
 我先干点别的  
 正在进行计算..  
 线程执行结果为：1

五、定时器

import java.util.Timer;
    import java.util.TimerTask;
    
    public class Demo5 {
    
    	public static void main(String[] args) {
    		
    		Timer timer = new Timer();
    		timer.schedule(new TimerTask() {
    			
    			@Override
    			public void run() {
    				//实现定时任务
    				System.out.println("定时任务执行..");
    			}
    		},0,1000);
    	}
    }

六、线程池的实现

import java.util.concurrent.ExecutorService;
    import java.util.concurrent.Executors;
    
    public class Demo6 {
    
    	public static void main(String[] args) {
    		
    		//创建带有10个线程的线程池
    		ExecutorService threadPool = Executors.newFixedThreadPool(10);
    		//ExecutorService threadPool = Executors.newCachedThreadPool();
    		for(int i = 0; i < 10; i++) {
    			threadPool.execute(new Runnable() {
    				@Override
    				public void run() {
    					System.out.println(Thread.currentThread().getName());
    				}
    			});
    		}
    		
    		threadPool.shutdown();
    	}
    }

七、Lambda表达式实现

import java.util.Arrays;
    import java.util.List;
    
    public class Demo7 {
    
    	public int add(List<Integer> l) {
    		l.parallelStream().forEach(System.out::print);
    		//结果：30  20  40  10  说明parallelStream为并行执行流
    		l.stream().forEach(System.out::print);
    		//结果：10  20  30  40  说明stream不是并行执行流
    		return l.parallelStream().mapToInt(a -> a).sum();
    	}
    	
    	public static void main(String[] args) {
    		List<Integer> l = Arrays.asList(10,20,30,40);
    		int result = new Demo7().add(l);
    		System.out.println("求和结果："+result);
    	}
    }