java 多线程并行_Java线程与并行编程(一)

你好，我是goldsunC

让我们一起进步吧！

进程与线程

进程是程序的一次动态执行过程，它对应从代码加载、执行到执行完毕的一个完整过程。这个过程也是进程本身从产生、发展到消亡的过程，同一段程序，可以被多次的加载到系统中的不同内存区域分别执行，从而形成不同的进程。

线程是比进程更小的执行单位，一个进程在执行过程中可以产生多个线程。每个线程都有它自己的产生、存在和消亡过程。当你开启一个新的进程时，系统都会给进程分发一块专用的内存区域，并以PCB(进程控制块)作为它的标志。而线程间可以共享相同的内存，并可以利用这些共享单元来实现数据交换、实时通信与必要的同步操作。

线程

一个线程应该包括三个部分：代码、数据以及CPU。CPU：虚拟的CPU，用于执行该线程的任务。

代码：即线程中需要执行的指令，在程序中表现为特定的方法。

数据：即线程中要处理的数据，在程序中表现为各变量。

在Java中，由java.lang.Thread类来实现线程。

为了构造Thread类对象，可以像Thread的构造函数中传递一个Runnable对象，这个对象是线程所需要的代码和数据的封装。

这个Runnable对象是指任何实现了java.lang.Runable接口的对象，Runnable接口只有一个方法public void run()，这个方法里面应包含线程需要执行的代码。

如果要启动线程中的代码，只需要执行Thread类的start()方法即可，系统会自动取执行run()方法中规定的代码。

创建线程的两种方法

继承Thread

你可以从Thread派生出一个新的类，可以在其中加入需要的属性和方法，同时需要覆盖run()方法，不需要重写start()方法，当你创建好这样一个对象后，调用start()方法即可启动该线程。

需要注意的是，虽然run()方法包含了线程要执行的指令，但是我们一般不直接调用它，而是调用start()来启动线程。

如下一个示例：

public class Thread1 {

public static void main(String[] args) {

MyThread1 th1 = new MyThread1();

MyThread1 th2 = new MyThread1();

th1.start();

th2.start();

}

}

class MyThread1 extends Thread {

public void run() {

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

System.out.print(" "+i);

}

}

OUT:

0 1 0 1 2 3 4 5 6 7 2 8 3 9 4 5 6 7 8 9

该示例通过继承Thread类定义了自己线程类，然后用new创建了两个线程对象并启动。可以看到输出为两个线程同时执行的结果。

向Thread传递Runnable对象

如下一个示例：

public class Thread2 {

public static void main(String[] args) {

MyJob job1 = new MyJob(20);

MyJob job2 = new MyJob(20);

Thread thread1 = new Thread(job1);

Thread thread2 = new Thread(job2);

thread1.start();

thread2.start();

}

}

class MyJob implements Runnable {

private int num;

public MyJob(int num) {

this.num = num;

}

@Override

public void run() {

for (int i=0; i

System.out.print(" "+i);

}

}

OUT:

0 0 1 1 2 2 3 3 4 4 5 5 6 6 7 7 8 8 9 9 10 11 10 12 11 13 12 13 14 14 15 15 16 16 17 17 18 18 19 19

如上程序首先定义了一个MyJob类，它实现了Runnable接口，重写了run()方法。在创建线程时先创建了两个MyJob对象，然后向Thread构造函数中传入该对象，即可使用start()方法启动线程。

上面两种方法都可以创建线程，但是实现方式略有不同，当然也有相同的地方，接下来我们对比分析一下两者的不同及特点。继承Thread：直接继承Thread的话，实现起来简单一些，可以直接操纵线程，但是如果你继承了Thread类，就不能再从其他类继承。

实现Runnable接口：这种方法实现起来稍微麻烦一点，但是可以将Thread类与要处理任务的类分离开，我们定义专门的任务类，可以形成比较清晰的模型。同时实现此接口的同时可以继承其他类。

需要注意的是，如果直接继承Thread类，那么在类中this即指当前的线程对象，而使用Runnable接口的话，需要在类中使用Thread.currentThread()方法来获得当前的线程。

使用匿名类及Lambda表达式

在创建线程时，还可以实现匿名类！而且因为Runnable接口是函数式接口，所以可以写成Lambda表达式！还记得函数式接口是什么吗？它就是只含有一个抽象方法的接口。这个很重要哦。

如下一个示例：

public class Thread3 {

public static void main(String[] args) {

new Thread() {

public void run() {

for (int i=0;i<20;i++)

System.out.print(" "+i);

}

}.start();

new Thread(()->{

for (int i=0;i<20;i++)

System.out.print(" "+i);

}).start();

}

}

OUT:

0 1 2 3 4 5 6 7 8 9 10 11 12 0 13 1 14 2 15 3 16 4 17 5 18 6 19 7 8 9 10 11 12 13 14 15 16 17 18 19

如上示例中分别用了匿名类和Lambda表达式创建了两个线程。

Timer类

程序中，有一些任务需要隔一定的实际重复执行，实现这样的任务可以使用Timer类。

Timer类的常用构造方法如下：

Timer timer = new Timer("名字");

Timer类可以用以下方法来实现任务的调度：

schedule(TimerTask task, long delay, long period);

其中，TimerTask是表示所要重复执行的任务，在实际使用时要继承抽象类TimerTask并实现其中的run方法，delay表示第一次执行前要等待的时间(毫秒)，period是没两次执行的时间间隔(毫秒)。

如下一个示例：

import java.util.Date;

import java.util.Timer;

import java.util.TimerTask;

public class TimerTest {

public static void main(String[] args) {

Timer timer = new Timer("goldsunC");

TimerTask task = new MyTask();

timer.schedule(task,1000,1000);

}

}

class MyTask extends TimerTask {

int n = 0;

public void run() {

n++;

System.out.print(new Date());

System.out.println("---"+n);

}

}

这个实例会在屏幕上每隔1秒打印一次当前时间，用到了Timer及schedule方法。