Java并发编程之线程创建介绍（Java高并发编程详解:多线程与架构设计）

Java并发编程之线程创建介绍（Java高并发编程详解:多线程与架构设计）

目录1.线程与进程2.线程的创建与运行

1.线程与进程

进程是代码在数据集合上的一次运行活动，是系统进行资源分配和调度的基本单位，线程则是一个实体，一个进程中至少有一个线程，是CPU调度和分配的基本单位，进程中的多个线程http://共享进程的资源。

进程的三个特征：

动态性 ： 进程是运行中的程序，要动态的占用内存，CPU和网络等资源。独立性 ： 进程与进程之间是相互独立的，彼此有自己的独立内存区域。并发性 ： 假如CPU是单核，同一个时刻其实内存中只有一个进程在被执行。CPU会分时轮询切换依次为每个进程服务，因为切换的速度非常快，给我们的感觉这些进程在同时执行，这就是并发性。

2.线程的创建与运行

我们在进程中创建线程的方式有三种:

方式一：继承Thread类的方式1.定义一个线程类继承Thread类。2.重写run()方法3.创建一个新的线程对象。4.调用线程对象的start()方法启动线程。

public class ThreadDemo {

// 启动后的ThreadDemo当成一个进程。

// main方法是由主线程执行的，理解成main方法就是一个主线程

public static void main(String[] args) {

// 3.创建一个线程对象

Thread t = new MyThread();

// 4.调用线程对象的start()方法启动线程,最终还是执行run()方法！

t.start();

for(int i = 0 ; i < 100 ; i++ ){

System.out.println("main线程输出："+i);

}

}

}

// 1.定义一个线程类继承Thread类。

class MyThread extends Thread{

// 2.重写run()方法

@Override

public void run() {

// 线程的执行方法。

for(int i = 0 ; i < 100 ; i++ ){

System.out.println("子线程输出："+i);

}

}

}

优点：编码简单，在run()方法内获取当前线程直接使用this就可以了，无需使用Thread.currentThread()方法。 缺点：线程类已经继承了Thread类无法继承其他类了，功能不能通过继承拓（单继承的局限性）。另外任务与代码没有分离，当多个线程执行一样的任务时需要多份任务代码。

小结：

线程类是继承了Thread的类。启动线程必须调用start()方法。多线程是并发抢占CPU执行，所以在执行的过程中会出现并发随机性

方式二：实现Runnable接口的方式。

1.创建一个线程任务类实现Runnable接口。2.重写run()方法3.创建一个线程任务对象。4.把线程任务对象包装成线程对象5.调用线程对象的start()方法启动线程。

public class ThreadDemo {

public static void main(String[] args) {

// 3.创建一个线程任务对象(注意：线程任务对象不是线程对象，只是执行线程的任务的)

Runnable target = new MyRunnable();

// 4.把线程任务对象包装成线程对象.且可以指定线程名称

// Thread t = new Thread(target);

Thread t = new Thread(target,"1号线程");

// 5.调用线程对象的start()方法启动线程

t.start();

Thread t2 = new Thread(target);

// 调用线程对象的start()方法启动线程

t2.start();

for(int i = 0 ; i < 10 ; i++ ){

System.out.println(Thread.currentThread().getName()+"==>"+i);

}

}

}

// 1.创建一个线程任务类实现Runnable接口。

class MyRunnable implements Runnable{

// 2.重写run()方法

@Override

public void run() {

for(int i = 0 ; i < 10 ; i++ ){

System.out.println(Thread.currentThread().getName()+"==>"+i);

}

}

}

优点：

线程任务类只是实现了Runnable接口，可以继续继承其他类，而且可以继续实现其他接口（避免了单继承的局限性）。 同一个线程任务对象可以被包装成多个线程对象,适合多个多个线程去共享同一个资源。实现解耦操作，线程任务代码可以被多个线程共享，线程任务代码和线程独立。

方法三：实现Callable接口

1.定义一个线程任务类实现Callable接口 ， 申明线程执行的结果类型。2.重写线程任务类的call方法，这个方法可以直接返回执行的结果。3.创建一个Callable的线程任务对象。4.把Callable的线程任务对象包装成一个FutureTask对象。5.把FutureTask对象包装成线程对象。6.调用线程的start()方法启动线程 。

public class ThreadDemo {

public static void main(String[] args) {

// 3.创建一个Callable的线程任务对象

Callable call = new MyCallable();

// 4.把Callable任务对象包装成一个未来任务对象

// -- public FutureTask(Callable callable)

// 未来任务对象是啥，有啥用？

// -- 未来任务对象其实就是一个Runnable对象:这样就可以被包装成线程对象！

// -- 未来任务对象可以在线程执行完毕之后去得到线程执行的结果。

FutureTask task = new FutureTask<>(call);

// 5.把未来任务对象包装成线程对象

Thread t = new Thread(task);

// 6.启动线程对象

t.start();

for(int i = 1 ; i <= 10 ; i++ ){

System.out.println(Thread.currentThread().getName()+" => " + i);

}

// 在最后去获取线程执行的结果,如果线程没有结果，让出CPU等线程执行完再来取结果

try {

String rs = task.get(); // 获取call方法返回的结果（正常/异常结果）

System.out.println(rs);

} catch (Exception e) {

e.printStackTrace();

}

}

}

// 1.创建一个线程任务类实现Callable接口，申明线程返回的结果类型

class MyCallable implements Callable{

// 2.重写线程任务类的call方法！

@Override

public String call() throws Exception {

// 需求：计算1-10的和返回

int sum = 0 ;

for(int i = 1 ; i <= 10 ; i++ ){

System.out.println(Thread.currentThread().getName()+" => " + i);

sum+=i;

}

return Thread.currentThread().getName()+"执行的结果是："+sum;

}

}

优点： 线程任务类只是实现了Callable接口，可以继续继承其他类，而且可以继续实现其他接口（避免了单继承的局限性）。 同一个线程任务对象可以被包装成多个线程对象，适合多个多个线程去共享同一个资源。实现解耦操作，线程任务代码可以被多个线程共享，线程任务代码和线程独立。最关键的是能直接得到线程执行的结果。http://

版权声明：本文内容由网络用户投稿，版权归原作者所有，本站不拥有其著作权，亦不承担相应法律责任。如果您发现本站中有涉嫌抄袭或描述失实的内容，请联系我们jiasou666@gmail.com 处理，核实后本网站将在24小时内删除侵权内容。