1: 概念
进程:
进程是指在系统中正在运行的一个应用程序.每个进程之间是独立的,每个进程均运行在其专用且受保护的内存空间内.
例如, 平时打开的酷狗音乐听歌, 就是一个进程.
(多)线程:
线程有时被称为轻量进程(Lightweight Process,LWP),是程序执行流的最小单元.
线程是程序中一个单一的顺序控制流程.进程内有一个相对独立的、可调度的执行单元,是系统独立调度和分派CPU的基本单位指令运行时的程序的调度单位.在单个程序中同时运行多个线程完成不同的工作,称为多线程.
进程&线程关系:
进程想要执行任务,必须有线程(每一个进程至少要有一条线程);
线程是进程的执行单元,一个进程(程序)的所有任务都在线程中执行.
通常, 线程中的任务的执行都是串行的, 在一个时间内, 一个线程只能执行一个任务.
为什么要多线程:
可以在一个进程中开启多条线程, 每条线程可以并行(同行)执行不同的任务,充分利用CPU,适当的提高程序的执行效率.
2: 多线程中常用方法
| 方法 | 说明 |
|---|---|
| currentThread | 返回当前正在执行的线程对象的应用 |
| start | 使该线程开始执行；Java 虚拟机调用该线程的 run 方法. 注意, 不要调用run方法启动线程, 启动线程是start, 如果调用run方法, 相当于在主线程中调用run方法, 和普通的方法的调用没有区别, 此时不会创建一个新的线程来执行定义的任务 |
| run | 如果该线程是使用独立的Runnable运行对象构造的,则调用该Runnable对象的run方法;否则,该方法不执行任何操作并返回. |
| setName | 改变线程名称,使之与参数name相同. |
| setPriority | 改变线程的优先级 |
| setDeamon | 设置线程为守护线程或用户线程 |
| interrupt | 中断线程 |
| isAlive | 测试线程是否处于活动状态. |
| yield | 暂停当前正在执行的线程对象, 并执行其他线程 |
| sleep | 让当前正在执行的线程休眠指定的毫秒数 |
3: 如何创建线程
1: 普通创建 Thread() 对象
2: 继承 Thread 类
3: 实现 Runnable 接口
4: 实现 Callable 接口, 实现Callable接口后, 可以有返回值
4: 实例讲解多线程
例子1(new Thread):
//================Demo1
public class Demo1 {
public static void main(String[] args) throws InterruptedException {
Thread thread1 = new Thread("thread1");
thread1.sleep(5000);
System.out.println("线程名称: " + thread1.currentThread().getName());
Thread thread2 = new Thread("thread2");
thread2.sleep(5000);
System.out.println("线程名称: " + thread2.currentThread().getName());
}
}
//================Demo2
public class Demo2 {
public static void main(String[] args) {
Thread thread1 = new Thread("Thread1"){
public void run() {
try {
Thread.sleep(5000);
System.out.println("线程名称: " + Thread.currentThread().getName());
} catch (InterruptedException e) {
e.printStackTrace();
}
};
};
thread1.start();
Thread thread2 = new Thread("Thread2"){
public void run() {
try {
Thread.sleep(5000);
System.out.println("线程名称: " + Thread.currentThread().getName());
} catch (InterruptedException e) {
e.printStackTrace();
}
};
};
thread2.start();
}
}
认真体会一下上面2个demo, 想一想, 他们执行完所花的时间一样都是10毫秒吗?
答案是否定的, Demo1执行时间10毫秒, Demo2执行时间为5毫秒. why?
因为第一个是在同一个主线程中. 打印的结果可以看到
Demo1:
线程名称: main
线程名称: main
Demo2:
线程名称: Thread2
线程名称: Thread1
例子2(extend Thread):
public class Main {
public static void main(String[] args) {
for (int i=0; i< 5; i++){
Thread thread = new MyThread();
thread.start();
}
}
}
public class MyThread extends Thread{
DateFormat df = new SimpleDateFormat("yyyy年MM月dd日HH时mm分ss秒S毫秒");
@Override
public void run() {
String name = Thread.currentThread().getName();
System.out.println(df.format( new Date()) + " Thread:" + name + " start.");
try {
Thread.sleep(5000);
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println(df.format( new Date()) + " Thread:" + name + " end.");
}
}
===============以下是执行结果
2018年09月25日18时35分10秒913毫秒 Thread:Thread-0 start.
2018年09月25日18时35分10秒914毫秒 Thread:Thread-1 start.
2018年09月25日18时35分10秒915毫秒 Thread:Thread-2 start.
2018年09月25日18时35分10秒916毫秒 Thread:Thread-3 start.
2018年09月25日18时35分10秒916毫秒 Thread:Thread-4 start.
2018年09月25日18时35分15秒914毫秒 Thread:Thread-1 end.
2018年09月25日18时35分15秒914毫秒 Thread:Thread-0 end.
2018年09月25日18时35分15秒916毫秒 Thread:Thread-2 end.
2018年09月25日18时35分15秒916毫秒 Thread:Thread-4 end.
2018年09月25日18时35分15秒916毫秒 Thread:Thread-3 end.
例子3(实现Runnable接口):
public class Main {
public static void main(String[] args) {
for(int i=0; i<5; i++){
Thread thread = new Thread(new MyRunnable());
thread.start();
}
}
}
public class MyRunnable implements Runnable {
@Override
public void run() {
String name = Thread.currentThread().getName();
DateFormat df = new SimpleDateFormat("yyyy年MM月dd日HH时mm分ss秒S毫秒");
System.out.println(df.format(new Date()) + " Thread:" + name + " start.");
try {
Thread.sleep(10000);
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println(df.format(new Date()) + " Thread:" + name + " end.");
}
}
//===================结果, 也是只花了10秒
2018年09月25日18时41分43秒255毫秒 Thread:Thread-4 start.
2018年09月25日18时41分43秒255毫秒 Thread:Thread-2 start.
2018年09月25日18时41分43秒255毫秒 Thread:Thread-0 start.
2018年09月25日18时41分43秒255毫秒 Thread:Thread-1 start.
2018年09月25日18时41分43秒260毫秒 Thread:Thread-3 start.
2018年09月25日18时41分53秒257毫秒 Thread:Thread-4 end.
2018年09月25日18时41分53秒258毫秒 Thread:Thread-2 end.
2018年09月25日18时41分53秒258毫秒 Thread:Thread-0 end.
2018年09月25日18时41分53秒258毫秒 Thread:Thread-1 end.
2018年09月25日18时41分53秒262毫秒 Thread:Thread-3 end.
例子4(实现Callable接口):
实现callable之后, 如果有返回值的话, 就需要放到线程池中, 待全部执行完了, 一起返回.
public class Main {
public static void main(String[] args) {
int poolsize = 3;
Date start = new Date();
List<Future> list = new ArrayList<Future>();
ExecutorService pool = Executors.newFixedThreadPool(poolsize);
for(int i =0; i<poolsize; i++){
Callable thread = new MyCallable();
Future result = pool.submit(thread);
list.add(result);
}
pool.shutdown();
list.forEach(item -> {
try {
System.out.println("线程返回值为: " + item.get().toString());
} catch (Exception e) {
e.printStackTrace();
}
});
Date end = new Date();
long sec = end.getTime() - start.getTime();
System.out.println("总共花费: " + sec + " 毫秒!");
}
}
public class MyCallable implements Callable {
@Override
public Object call() throws Exception {
DateFormat df = new SimpleDateFormat("yyyy年MM月dd日HH时mm分ss秒S毫秒");
String name = Thread.currentThread().getName();
System.out.println(df.format(new Date()) + " Thread:" + name + " start.");
Thread.sleep(10000);
System.out.println(df.format(new Date()) + " Thread:" + name + " end.");
return name;
}
}
//===================结果, 也是只花了10秒
2018年09月25日18时45分54秒713毫秒 Thread:pool-1-thread-2 start.
2018年09月25日18时45分54秒716毫秒 Thread:pool-1-thread-3 start.
2018年09月25日18时45分54秒716毫秒 Thread:pool-1-thread-1 start.
2018年09月25日18时46分04秒714毫秒 Thread:pool-1-thread-2 end.
2018年09月25日18时46分04秒717毫秒 Thread:pool-1-thread-3 end.
2018年09月25日18时46分04秒717毫秒 Thread:pool-1-thread-1 end.
线程返回值为: pool-1-thread-1
线程返回值为: pool-1-thread-2
线程返回值为: pool-1-thread-3
总共花费: 10051 毫秒!
