java并发和多线程的关系 java并发线程代码

前言

Java 中实现多线程的方式有三种，下面我们会详细了解这三种方式

正文

Thread

第一种是线程类继承Thread类， 实现run方法,  然后线程类调用start方法。 线程类启动的时候会执行线程类中run方法

public class ThreadDemo extends Thread{
	@Override
	public void run(){
		try {
			sleep(1000);
		} catch (InterruptedException e) {
			e.printStackTrace();
		}
		System.out.println(Thread.currentThread().getName()+": 2");
	}

	public static void main(String[] args) {
		ThreadDemo threadDemo = new ThreadDemo();
		threadDemo.start();

		System.out.println(Thread.currentThread().getName() + ": 1");
	}
}

输出结果：

main: 1
Thread-0: 2

通过输出结果，我们可以看到 “1” 通过main线程输出的， “2” 是通过Thread-0输出的两个线程

这里我忽然一个问题， 如果thradDemo直接调用run方法会是什么效果呢，报错吗

public static void main(String[] args) {
		ThreadDemo threadDemo = new ThreadDemo();
		//threadDemo.start();
		threadDemo.run();

		System.out.println(Thread.currentThread().getName() + ": 1");
	}

输出结果

main: 2
main: 1

这里1和2都是main线程调用的，且 2在1的前面，就说明main线程是顺序调用的。

我想取看下他的源码，首先我们看下类的描述

public class Thread
extends Object implements Runnable

Thread是一个线程在执行一个程序。java虚拟机的应用程序可以有多个同时执行的线程。

当Java虚拟机启动时，通常只有一个非守护进程线程（它通常调用某个指定类中名为main的方法）。Java虚拟机将继续执行线程，直到发生以下任一情况：

• 类运行时的exit方法已被调用，并且安全管理器已允许执行exit操作。
• 所有不是守护进程线程的线程都已死亡，要么是通过调用run方法返回，要么是通过抛出传播到run方法之外的异常。

有两种方法可以创建新的执行线程。一种是将类声明为Thread的子类。这个子类应该重写类Thread的run方法。然后可以分配并启动子类的实例。例如，计算大于规定值的素数的线程可以按如下方式编写：

---

class PrimeThread extends Thread {
         long minPrime;
         PrimeThread(long minPrime) {
             this.minPrime = minPrime;
         }

         public void run() {
             // compute primes larger than minPrime
              . . .
         }
     }

---

下面的代码将创建一个线程并开始运行：

PrimeThread p = new PrimeThread(143);
     p.start();

创建一个线程是声明一个类实现Runnable接口的其他方式。该类实现run方法。那类的一个实例可以分配，作为一个参数传递Thread时创建，并开始。同样的例子在这个其他风格看起来像以下：

---

class PrimeRun implements Runnable {
         long minPrime;
         PrimeRun(long minPrime) {
             this.minPrime = minPrime;
         }

         public void run() {
             // compute primes larger than minPrime
              . . .
         }
     }

---

下面的代码将创建一个线程并开始运行：

PrimeRun p = new PrimeRun(143);
     new Thread(p).start();

为了便于识别，每个线程都有一个名称。多个线程可能具有相同的名称。如果在创建线程时未指定名称，则会为其生成新名称。

runnable

public class RunableDemo implements Runnable{
	public static void main(String[] args) {
		RunableDemo runableDemo = new RunableDemo(0);
		new Thread(runableDemo).start();

		System.out.println(Thread.currentThread().getName() +  " minPrime：" + runableDemo.getMinPrime());

	}

	public long getMinPrime() {
		return minPrime;
	}

	long minPrime;
	RunableDemo(long minPrime) {
		this.minPrime = minPrime;
	}


	@Override
	public void run() {
		minPrime ++;
		try {
			Thread.sleep(1000);
		} catch (InterruptedException e) {
			e.printStackTrace();
		}

		System.out.println(Thread.currentThread().getName() +  " minPrime：" + this.getMinPrime());
	}

}

输出结果

main minPrime：0
Thread-0 minPrime：1

为什么要使用runnable, 是因为，多个线程可以操作同一个对象，而继承Thread的话都是不同对象处理自己相对应线程对象

Callable、Future

无论Runnable还是继承Thread都是没有返回值，但是会有这个的需求，所以1.5引入了Callable、Future的概念

public class CallableDemo implements Callable<String> {
	@Override
	public String call() throws Exception {
		Thread.sleep(1000);
		System.out.println(Thread.currentThread().getName() + ": callable");
		return "callable";
	}

	public static void main(String[] args) {
		Callable<String> callable = new CallableDemo();
		FutureTask task = new FutureTask(callable);
		new Thread(task).start();
		try {
			//获取子线程的返回值
			System.out.println(Thread.currentThread().getName() + ": main");
			System.out.println("子线程返回值：" + task.get() + "\n");
		} catch (Exception e) {
			e.printStackTrace();
		}
	}
}

输出结果

main: main
Thread-0: callable
子线程返回值：callable

三种方式的对比

第一种和后面两种的对比：

1、通过代码可以看出，第一种方法是最简洁方便的，直接就可以start，不需要任何转换
2、但是第一种有一个很不好的地方就是继承了Thread类后由于java的单继承机制，就不可以继承其他的类了，而如果实现的是接口，就可以实现多个接口，使开发更灵活。

第二种和第三种方式对比：

1、同样的，第二种方法相对第三种方式来说代码更简洁，使用更方便，少了一次转换
2、第三种方法有两个优点：有返回值、可以抛出异常