【并发编程】-创建多线程的七种方法

一、继承Thread类

public class Demo1 extends Thread {
	
	public Demo1(String name) {
		super(name);
	}
	
	@Override
	public void run() {
		//线程正确的结束方式,就是线程执行完毕,线程执行完毕自然就结束了
		//终止线程用interrupted(),如果不中断就执行;
		//当main()方法调用了interrupt()后,标志改了中断,线程结束
		while(!interrupted()) {
			System.out.println(getName() + "线程执行了 .. ");
			try {
				Thread.sleep(200);
			} catch (InterruptedException e) {
				e.printStackTrace();
			}
		}
	}
	
	public static void main(String[] args) {	
		Demo1 d1 = new Demo1("first-thread");
		Demo1 d2 = new Demo1("second-thread");
	
		d1.start();
		d2.start();
		
		//stop()方法在jdk1.6已经失效,因为线程只是无限期的等待,获取的资源并没有释放
		//d1.stop();
		//当调用了interrupt()后,标志改了中断,线程结束
		d1.interrupt();
	}	
}

二、实现Runnable接口

//使用Runnable,面向接口编程,使任务和业务分离
//实现Runnable接口的demo2只是一个普通类,作为一个线程任务存在,创建并启用时需要当做参数传入
public class Demo2 implements Runnable {

	@Override
	public void run() {
		while(true) {
			System.out.println("thread running ...");
		}
	}

	public static void main(String[] args) {
		//Runnable对象作为Thread对象的target,Runnable实现类里面包含run方法仅仅作为执行体。
		//也就是说Thread类的作用是把run方法包装成线程的执行体。
		//实际运行的线程对象依然是Thread实例,只是该Thread线程负责执行其target的run方法。
		Thread thread = new Thread(new Demo2());
		//调用start方法,还会调用Thread的run方法,根据源码可知,
		//调用了Tread的run方法最后还是调用了调用的Runnable(target)的run方法
		thread.start();
	}	
}

三、实现Callable接口
callable类似于runnable的方式,只有一个方法call(),但是是一个有返回值的方法,这给我们提供了获取方法执行结果的可能,即使它是个异步的任务,它可以获取异常,给我们极大地便利知道任务执行失败的原因。

public class Demo3 implements Callable<Integer> {
	
	public static void main(String[] args) throws Exception {
		Demo3 d = new Demo3();
		
		FutureTask<Integer> task = new FutureTask<>(d);
		
		Thread t = new Thread(task);
		
		t.start();
		
		System.out.println("我先干点别的。。。");
		
		Integer result = task.get();
		System.out.println("线程执行的结果为:" + result);
	}

	@Override
	public Integer call() throws Exception {
		System.out.println("正在进行紧张的计算....");
		Thread.sleep(3000);
		return 1;
	}
}

四、匿名内部类的方式
如果线程我们只需要执行一次,就不需要创建一个类,然后再去创建一个线程了,只需要在代码逻辑中直接重写Thread类中的run方法或者直接重写Runnable类中的run方法即可。

public class Demo4 {
	public static void main(String[] args) {
		
		/*new Thread() {
			public void run() {
				System.out.println("thread start ..");
			};
		}.start();*/
			
		/*new Thread(new Runnable() {
			@Override
			public void run() {
				System.out.println("thread start ..");
			}
		}).start();*/	
	}
}

五、线程池
线程池,其实就是一个容纳多个线程的容器,其中的线程可以反复使用,省去了频繁创建线程对象的操作,无需反复创建线程而消耗过多资源。

public class Demo6 {

	public static void main(String[] args) {
		//创建一个可缓存的线程池;
		//创建线程池有四种方法,分别是:
		//newSingleThreadExecutor,单线程线程池
		//newFixedThreadPool,固定大小的线程池
		//newCachedThreadPool,可缓存的线程池
		//newScheduledThreadPool,无限大小的线程池
		ExecutorService threadPool = Executors.newCachedThreadPool();

		for (int i = 0; i < 1000; i++) {
			threadPool.execute(new Runnable() {
				@Override
				public void run() {
					System.out.println(Thread.currentThread().getName());
				}
			});
		}
		//关闭线程池
		threadPool.shutdown();
	}

}

六、springboot配置线程池使用多线程
1、配置线程池

//利用EnableAsync来开启Springboot对于异步任务的支持
@Configuration
@EnableAsync
public class ThreadConfig implements AsyncConfigurer {
  
  @Override
  public Executor getAsyncExecutor() {
    ThreadPoolTaskExecutor executor = new ThreadPoolTaskExecutor();
    executor.setCorePoolSize(5);
    executor.setMaxPoolSize(15);
    executor.setQueueCapacity(25);
    executor.initialize();
    return executor;
  }

  @Override
  public AsyncUncaughtExceptionHandler getAsyncUncaughtExceptionHandler() {
    return null;
  }
}

2、任务执行代码

@Service
public class AsyncTaskService {
  //注解@Async表明该方法是异步方法
  @Async
  public void executeAsyncTask(int i) {
    System.out.println("线程" + Thread.currentThread().getName() + " 执行异步任务:" + i);
  }
}

3、测试

public class SpringbootLearnApplicationTests {
  @Autowired
  private AsyncTaskService asyncTaskService;
  @Test
  public void contextLoads() {
  }
  @Test
  public void threadTest() {
    for (int i = 0; i < 20; i++) {
      asyncTaskService.executeAsyncTask(i);
    }
  }
}

七、Lambda表达式实现多线程

public class Demo7 {
	public static void main(String[] args) {		
		List<Integer> values = Arrays.asList(10,20,30,40);
		int res = new Demo7().add(values);
		System.out.println("计算的结果为:" + res);			
	}
	
	public int add (List<Integer> values) {
//		values.parallelStream().forEach(System.out :: println);
		//parallelStream()方法是并行执行的,而stream()方法是串行执行的
		return values.parallelStream().mapToInt( i -> i * 2).sum();
	}
}

如果想要验证parallelStream()是否是并行执行的,可以利用这个方法打印一下list中的元素,如果打印出来的元素是乱序的,那么就是并行执行的。

values.parallelStream().forEach(System.out :: println);

执行后打印出来的结果如下:
在这里插入图片描述

values.stream().forEach(System.out :: println);

而执行普通的stream流打印结果如下:
在这里插入图片描述

评论 1
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

木子松的猫

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付:¥1
获取中
扫码支付

您的余额不足,请更换扫码支付或充值

打赏作者

实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值