以下对并发、并行、进程、线程的理解引自 阿里巴巴技术专家Hollis
一、并发
并发（Concurrent），在操作系统中，是指一个时间段中有几个程序都处于已启动运行到运行完毕之间，且这几个程序都是在同一个处理机上运行。
无论是Windows、Linux还是MacOS等其实都是多用户多任务分时操作系统。使用这些操作系统的用户是可以“同时”干多件事的
二、并行
并行（Parallel），当系统有一个以上CPU时，当一个CPU执行一个进程时，另一个CPU可以执行另一个进程，两个进程互不抢占CPU资源，可以同时进行，这种方式称之为并行(Parallel)
三、进程
对于操作系统来说，一个任务，一个应用程序就是一个进程（Process）
如打开一个浏览器就是启动一个浏览器进程，打开一个记事本就是启动一个记事本进程
四、线程
在一个进程内部，要同时干多件事，就需要同时运行多个“子任务”，我们把进程内的这些“子任务”称为线程（Thread）
如在一个记事本上打字，画图等子任务，这些子任务之间共用同一个进程资源
进程当做资源分配的基本单元，线程当做执行的基本单元，同一个进程的多个线程之间共享资源
1、单核CPU如何做到多线程并发
实际上，对于单个CPU的计算机来说，在CPU中，同一时间只能干一件事儿。为了看起来像是“同时干多件事”，分时操作系统是把CPU的时间划分成长短基本相同的时间区间，即**”时间片”**，通过操作系统的管理，把这些时间片依次轮流地分配给各个用户使用。
如果某个作业在时间片结束之前,整个任务还没有完成，那么该作业就被暂停下来,放弃CPU，等待下一轮循环再继续做.此时CPU又分配给另一个作业去使用。
由于计算机的处理速度很快，只要时间片的间隔取得适当,那么一个用户作业从用完分配给它的一个时间片到获得下一个CPU时间片，中间有所”停顿”，但用户察觉不出来,好像整个系统全由它”独占”似的。
所以，在单CPU的计算机中，我们看起来“同时干多件事”，其实是通过CPU时间片技术，并发完成的。
2、线程创建的三种方式
1、继承java.lang.Thread类，重写run方法
/**
1、实现线程有3种方式：
1、编写一个类，直接继承java.lang.Thread，重写run方法
2、编写一个类实现java.lang.Runnable接口
3、编写类实现Callable接口，通过FutureTask创建
2、启动线程
调用线程对象的start()方法
start()方法的作用：启动一个分支线程，在JVM中开辟一个新的栈空间
run()方法不会启动线程，不会分配新的分支线程栈
*/
public class ThreadNewByExtend {
public static void main(String[] args) {
// 这里是main方法，这属于主线程，在主栈中运行
// 新建一个分支线程对象
Mythread t = new Mythread();
/**
* run()方法不会启动线程，不会分配新的分支栈（只调用run()不调用start()还是单线程）
* 会先执行 t 线程的 for循环，再执行 主线程main中的for循环
* */
//t.run();
/**
* start()方法的作用：启动一个分支线程，在JVM中开辟一个新的栈空间，这段代码任务完成之后，瞬间就结束了
* start()方法只是为了开启一个新的栈空间，只要新的栈空间开出来，start()方法就结束了,线程就启动成功了
* 启动成功的线程会自动调用run方法，并且run方法在分支栈的栈底部（压栈）
* run方法在分支栈的栈底部，main方法在主栈的栈底部；分支线程run和 主线程main是平级的
* */
t.start();
//主线程for循环
for (int i = 1;i <= 100;i++){
System.out.println("main----" + i);
}
}
}
class Mythread extends Thread {
//Ctrl+O
@Override
public void run() {
for (int i = 1;i <= 100;i++){
System.out.println("Mythread----" + i);
}
}
}
2、编写类实现java.lang.Runnable接口
/**
编写一个类实现java.lang.Runnable接口
*/
public class ThreadNewByRunnable {
public static void main(String[] args) {
MyRunnable runnable = new MyRunnable();
Thread t = new Thread(runnable);
t.start();
//采用匿名内部类方式
Thread t1 = new Thread(new Runnable() {
@Override
public void run() {
for (int i = 1;i <= 100;i++){
System.out.println("分支线程t1----" + i);
}
}
});
t1.start();
//主线程for循环
for (int i = 1;i <= 100;i++){
System.out.println("main----" + i);
}
}
}
class MyRunnable implements Runnable{
@Override
public void run() {
for (int i = 1;i <= 100;i++){
System.out.println("分支线程t----" + i);
}
}
}
3、编写类实现Callable接口，通过FutureTask创建（JDK8新特性）
import java.util.concurrent.Callable;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.FutureTask;
/**
实现线程的第三种方式：
实现Callable接口
优点：可以获取到线程的执行结果
缺点：效率比较低，在获取t线程执行结果的时候，当前线程受阻塞，效率较低
*/
public class ThreadNewByCallable {
public static void main(String[] args) {
// 创建一个“未来任务类”对象，参数：Callable接口实现类对象
FutureTask task = new FutureTask(new Callable() {
@Override
// call()方法就相当于run方法，这个方法有返回值
public Object call() throws Exception {
System.out.println("call begin");
Thread.sleep(1000 * 5);
System.out.println("call end");
return 100+50;
}
});
Thread t = new Thread(task);
t.setName("t");
t.start();
try {
// get()方法获取t线程的返回结果,但是会导致“当前线程阻塞”
Object obj = task.get();
System.out.println("线程执行结果:" + obj);
} catch (InterruptedException e) {
e.printStackTrace();
} catch (ExecutionException e) {
e.printStackTrace();
}
// main方法这里的程序要想执行必须等待get()方法的结束，而get()方法可能需要很久
// get()方法是为了拿另一个线程的执行结果
System.out.println("Hello World!");
}
}
3、线程常用方法
/**
1、获取当前线程对象
Thread t = Thread.currentThread();
2、获取线程对象的名字
String name = 线程对象.getName();
3、修改线程对象的名字
线程对象.setName("线程名字");
4、当线程没有设置名字的时候，默认的名字
Thread-0
Thread-1
.....
*/
public class ThreadMethod {
public static void main(String[] args) {
//获取当前线程对象，currentThread()
Thread t = Thread.currentThread();
//获取线程名字"main"，getName()
System.out.println(t.getName());
Thread t1 = new Thread();
Thread t2 = new Thread();
//线程默认名字：Thread-0；Thread-1
System.out.println(t1.getName());//Thread-0
System.out.println(t2.getName());//Thread-1
//设置线程名字，setName()
t1.setName("t1");
System.out.println(t1.getName());//t1
}
}
4、线程调度，线程优先级
（1）线程调度模型
【1】抢占式调度模型：
哪个线程的优先级比较高，抢到的CPU时间片的概率就高一些/多一些
java采用的就是抢占式调度模型
【2】均分式调度模型：
平均分配CPU时间片。每个线程占有的CPU时间片时间长度一样
（2）线程调度方法
【1】实例方法：
void setPriority(int newPriority) 设置线程的优先级
int getPriority() 获取线程优先级
最低优先级1
默认优先级是5
最高优先级10
优先级比较高的获取CPU时间片可能会多一些。（但也不完全是，大概率是多的。）
【2】静态方法：
static void yield() 让位方法
暂停当前正在执行的线程对象，并执行其他线程
yield()方法不是阻塞方法。让当前线程让位，让给其它线程使用
yield()方法的执行会让当前线程从“运行状态”回到“就绪状态”
注意：在回到就绪之后，有可能还会再次抢到。
【3】实例方法：
void join()
/**
* 线程优先级
*
* void setPriority(int newPriority) 设置线程的优先级
* int getPriority() 获取线程优先级
*
* 最低优先级1；默认优先级是5；最高优先级10
*
* */
public class ThreadPriority {
public static void main(String[] args) {
System.out.println("线程最高优先级："+Thread.MAX_PRIORITY);//10
System.out.println("线程最低优先级："+Thread.MIN_PRIORITY);//1
System.out.println("线程默认优先级："+Thread.NORM_PRIORITY);//5
//线程默认优先级
System.out.println(Thread.currentThread().getName() + "线程的默认优先级是：" + Thread.currentThread().getPriority());
Thread t = new Thread(new Runnable() {
@Override
public void run() {
for(int i = 0; i < 10000; i++){
System.out.println(Thread.currentThread().getName() + "-->" + i);
}
}
});
t.setName("t");
t.setPriority(10);
t.start();
Thread.currentThread().setPriority(1);
// 优先级较高的，只是抢到的CPU时间片相对多一些。
// 大概率方向更偏向于优先级比较高的。
for(int i = 0; i < 10000; i++){
System.out.println(Thread.currentThread().getName() + "-->" + i);
}
}
}
5、 线程状态图
线程是有状态的，并且这些状态之间也是可以互相流转的
Java中线程的状态分为6种：
1、初始(NEW)：新创建了一个线程对象，但还没有调用start()方法
2、运行(RUNNABLE)：Java线程中将就绪（READY）和运行中（RUNNING）两种状态笼统的称为“运行”。
（1）就绪（READY）:线程对象创建后，其他线程(比如main线程）调用了该对象的start()方法。该状态的线程位于可运行线程池中，等待被线程调度选中并分配cpu使用权 。
（2）运行中（RUNNING）：就绪(READY)的线程获得了cpu 时间片，开始执行程序代码
3、阻塞(BLOCKED)：表示线程阻塞于锁（关于锁，在后面章节会介绍）
4、等待(WAITING)：进入该状态的线程需要等待其他线程做出一些特定动作（通知或中断）
5、超时等待(TIMED_WAITING)：该状态不同于WAITING，它可以在指定的时间后自行返回
6、终止(TERMINATED)：表示该线程已经执行完毕。
扫一扫
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
