Java的并发编程:创建线程的多种方式

作者: Arvin Chen 分类: Java 来源: Break易站(www.breakyizhan.com)

这篇文章主要讲的是Java的并发编程:创建线程的多种方式,如果不了解线程之间的各个状态的话,可以查看:Java的并发编程:线程状态以及各个线程状态的关系这篇文章。
Java的并发编程:创建线程的多种方式有下面这几种方式:

  • 继承Thread类
  • 实现Runnable接口
  • 匿名内部类的方式
  • 带返回值的线程
  • 定时器(quartz)
  • 线程池的实现
  • Lambda表达式实现
  • Spring实现多线程

继承Thread类创建Java线程

package com.breakyizhan.thread.t2;

public class Demo1 extends Thread {
	
	public Demo1(String name) {
		super(name);
	}
	
	@Override
	public void run() {
		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();
		
//		d1.stop();
		d1.interrupt();
	}
	
}

实现Runnable接口创建Java线程

package com.breakyizhan.thread.t2;

/**
 * 作为线程任务存在
 * 
 * @author worker
 *
 */
public class Demo2 implements Runnable {

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

	public static void main(String[] args) {
		Thread thread = new Thread(new Demo2());
		thread.start();
	}
	
}

匿名内部类的方式创建Java线程

package com.breakyizhan.thread.t2;

public class Demo3 {
	
	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();*/
		
		
		new Thread(new Runnable() {
			@Override
			public void run() {
				System.out.println("runnable");
			}
		}) {
			public void run() {
				System.out.println("sub");
			};
		}.start();
		
		
	}

}

带返回值的线程

package com.breakyizhan.thread.t2;

import java.util.concurrent.Callable;
import java.util.concurrent.FutureTask;

public class Demo4 implements Callable<Integer> {
	
	
	public static void main(String[] args) throws Exception {
		Demo4 d = new Demo4();
		
		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;
	}

}

定时器(quartz)创建Java线程

package com.breakyizhan.thread.t2;

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("timertask is run");
			}
		}, 0, 1000);

	}

}

线程池实现创建Java线程

package com.breakyizhan.thread.t2;

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

public class Demo6 {

	public static void main(String[] args) {

		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();
	}

}

Lambda表达式实现创建Java线程

package com.breakyizhan.thread.t2;

import java.util.Arrays;
import java.util.List;

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);
		return values.parallelStream().mapToInt( i -> i * 2).sum();
	}

}

Spring实现多线程创建Java线程在以后可以继续了解一下。

  •   本文标题:Java的并发编程:创建线程的多种方式 - Break易站
    转载请保留页面地址:https://www.breakyizhan.com/java/6615.html

    "Java的并发编程:创建线程的多种方式"的笔记

    • Break易站

      2018年10月27日 下午4:29

      对于线程池实现创建Java线程,还可以用创建指定线程池里面有多少线程的方法来实现线程池的创建,具体代码如下:

      package com.breakyizhan.thread.t2;
      
      import java.util.concurrent.ExecutorService;
      import java.util.concurrent.Executors;
      
      public class Demo6 {
      
      	public static void main(String[] args) {
      
      		//ExecutorService threadPool = Executors.newCachedThreadPool();
      		ExecutorService threadPool = Executors.newFixedThreadPool(10);
      
      		for (int i = 0; i &lt; 100; i++) {
      			threadPool.execute(new Runnable() {
      				@Override
      				public void run() {
      					System.out.println(Thread.currentThread().getName());
      				}
      			});
      		}
      		threadPool.shutdown();
      	}
      }
      
      

      运行的结果是10个线程要执行100次,不是按顺序执行的,而是互相抢夺CPU的资源执行的,具体结果如下:

      pool-1-thread-2
      pool-1-thread-4
      pool-1-thread-3
      pool-1-thread-1
      pool-1-thread-6
      pool-1-thread-5
      pool-1-thread-8
      pool-1-thread-9
      pool-1-thread-7
      pool-1-thread-2
      pool-1-thread-4
      pool-1-thread-1
      pool-1-thread-1
      pool-1-thread-3
      ..................................................
    扫描二维码添加微信 
  • ,领取淘宝优惠券,淘宝购物更优惠。现在添加微信,还可以领取机械键盘优惠券!添加微信后,分享淘宝选中的机械键盘给淘宝机器人即可领取!
    支持我们,就用微信淘宝!

    发表笔记

    电子邮件地址不会被公开。 必填项已用*标注

    更多阅读