一、进程
概念:
进程就是在运行中的程序,也就是代表了程序占用的内存区域。 比如:360就是一个程序,而360运行时就有很多个进程在运行,如下图。
特点:
- 独立性:进程是系统中独立存在的实体,它可以有自己独立的资源和自己私有的地址空间, 没有线程本身同意的情况下,其他线程不可以直接访问此线程。
- 动态性:进程与程序的区别在于,程序只是一个静态的指令集合,而进程是正在系统中活动的指令的集合,而进程加入了时间的概念,进程拥有自己的生命周期和各种不同的状态,这些概念在程序中都是不具备的。
- 并发性:多个进程可以在单个处理器上并发执行,多个进程之间不会互相影响。
时间片:
时间片,即CPU分配给各个程序的时间,每个进程被分配一个时间段,称作它的时间片。即该进程允许运行的时间,使各个程序从表面上看是同时进行的。
如果在时间片结束时进程还在运行,则CPU将被剥夺并分配给另一个进程,将当前进程挂起。如果进程在时间片结束前阻塞或结束,则CPU当即进行切换,而不会造成CPU资源浪费。当又切换到之前执行的进程,把现场恢复,继续执行。
在宏观上:我们可以同时打开多个应用程序,每个程序并行,同时运行。1/3000ns
在微观上:由于只有一个CPU,一次只能处理程序要求的一部分,如何处理公平,一种方法就是引入时间片,每个程序轮流执行。多核提高了并发能力。
二、线程
概念:
线程是系统能够进行运算调度的最小单位
它被包含在进程之中,一个进程可以有多个线程,是进程中的实际运作单位
多线程扩展了多进程的概念,使得同一个进程可以同时并发处理多个任务。
简而言之,一个程序运行后至少一个进程,一个进程里包含一个线程(单线程)或者多个线程。
进程和线程的关系
从上图中可以看出一个操作系统中可以有多个进程,一个进程中可以有多个线程。
每个进程有自己独立的内存,每个线程共享一个进程中的内存,每个线程又有自己独立的内存。(记清这个关系,非常重要!)
所以想使用线程技术,得先有进程,进程的创建是OS创建的,你能实现吗?不能,一般都是c或者c++语言完成的。
三、多线程的特性
随机性
线程状态
线程生命周期,总共有五种状态:
新建状态(New):当线程对象对创建后,即进入了新建状态,如:Thread t = new MyThread();
就绪状态(Runnable):当调用线程对象的start()方法(t.start();),线程即进入就绪状态。处于就绪状态的线程,只是说明此线程已经做好了准备,随时等待CPU调度执行,并不是说执行了t.start()此线程立即就会执行;
运行状态(Running):当CPU开始调度处于就绪状态的线程时,此时线程才得以真正执行,即进入到运行状态。注:就绪状态是进入到运行状态的唯一入口,也就是说,线程要想进入运行状态执行,首先必须处于就绪状态中;
阻塞状态(Blocked):处于运行状态中的线程由于某种原因,暂时放弃对CPU的使用权,停止执行,此时进入阻塞状态,直到其进入到就绪状态,才有机会再次被CPU调用以进入到运行状态;
根据阻塞产生的原因不同,阻塞状态又可以分为三种:
a) 等待阻塞:运行状态中的线程执行wait()方法,使本线程进入到等待阻塞状态;
b) 同步阻塞:线程在获取synchronized同步锁失败(因为锁被其它线程所占用),它会进入同步阻塞状态;
c) 其他阻塞:通过调用线程的sleep()或join()或发出了I/O请求时,线程会进入到阻塞状态。当sleep()状态时、join()等待线程终止或者超时、或者I/O处理完毕时,线程重新转入就绪状态。死亡状态(Dead):线程执行完了或者因异常退出了run()方法,该线程结束生命周期。
四、多线程创建
继承Thread:
Thread类本质上是实现了Runnable接口的一个实例,代表一个线程的实例。启动线程的唯一方法就是通过Thread类的start()实例方法。Start()方法是一个native方法,它将通知底层操作系统,最终由操作系统启动一个新线程,操作系统将执行run()方法。这种方式实现多线程很简单,通过自己的类直接extend Thread,并复写run()方法,就可以启动新线程并执行自己定义的run()方法。模拟开启多个线程,每个线程调用run()方法。
实现Runnable接口:
如果自己的类已经extends另一个类,就无法多继承,此时,可以实现一个Runnable接口。
比较:
方式 | 优点 | 缺点 |
---|---|---|
Thread | 编写简单,如果需要访问当前线程,则无需使用Thread.currentThread()方法,直接使用this即可获得当前线程。 | 线程类已经继承了Thread类,所以不能再继承其他父类 |
Runnable | 线程类只是实现了Runnable接口或Callable接口,还可以继承其他类。在这种方式下,多个线程可以共享同一个target对象,所以非常适合多个相同线程来处理同一份资源的情况,从而可以将CPU、代码和数据分开,形成清晰的模型,较好地体现了面向对象的思想。 | 编程稍微复杂,如果要访问当前线程,则必须使用Thread.currentThread()方法。 |
卖票案例:
继承Thread
public class TestThread {
public static void main(String[] args) {
Ticket t1 = new Ticket("one");
Ticket t2 = new Ticket("two");
Ticket t3 = new Ticket("three");
Ticket t4 = new Ticket("four");
t1.start();
t2.start();
t3.start();
t4.start();
}
}
class Ticket extends Thread {
static int tickets = 100;
Ticket(String name) {
super(name);
}
public void run() {
while (true) {
// 1. 多线程中,数据不安全-- 原因是:多线程随机性的特点 + 访问延迟
// 2. 问题:重复卖同一张票,+ 卖负数的票
// 当tickets = 1时,t1,t2,t3,t4都可以干活
if (tickets > 0) {
// 当tickets = 1时,t1,t2,t3,t4睡了
try {
sleep(100);
} catch (InterruptedException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
// 当tickets = 1时,t1先醒,输出1,而票tickets变为0
// 当tickets = 2时,t1先醒,输出0,而票tickets变为-1
// 当tickets = 3时,t1先醒,输出-1,而票tickets变为-2
// 当tickets = 4时,t1先醒,输出-2,而票tickets变为-3
// 相同数据情况:当线程 tickets--还没输出时,另一个线程也来干活了
System.out.println(getName() + "卖票号:" + tickets--);
} else {
break;
}
}
}
}
实现Runnable
public class TestThread2 {
public static void main(String[] args) {
Ticket2 t = new Ticket2();
Thread t1 = new Thread(t, "one");
Thread t2 = new Thread(t, "two");
Thread t3 = new Thread(t, "three");
Thread t4 = new Thread(t, "four");
t1.start();
t2.start();
t3.start();
t4.start();
}
}
class Ticket2 implements Runnable {
int tickets = 100;
public void run() {
while (true) {
// 1. 多线程中,数据不安全-- 原因是:多线程随机性的特点 + 访问延迟
// 2. 问题:重复卖同一张票,+ 卖负数的票
// 当tickets = 1时,t1,t2,t3,t4都可以干活 java.lang
if (tickets > 0) {
// 当tickets = 1时,t1,t2,t3,t4睡了
try {
Thread.sleep(100);
} catch (InterruptedException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
// 当tickets = 1时,t1先醒,输出1,而票tickets变为0
// 当tickets = 2时,t1先醒,输出0,而票tickets变为-1
// 当tickets = 3时,t1先醒,输出-1,而票tickets变为-2
// 当tickets = 4时,t1先醒,输出-2,而票tickets变为-3
// 相同数据情况:当线程 tickets--还没输出时,另一个线程也来干活了
System.out.println(Thread.currentThread().getName() + "卖票号:" + tickets--);
} else {
break;
}
}
}
}
运行之后会产生几个问题:
1、 产生超卖,-1张、-2张。
2、 产生重卖,同一张票卖给多人。
3、 多线程安全问题是如何出现的?常见情况是由于线程的随机性+访问延迟。
4、 以后如何判断程序有没有线程安全问题?在多线程程序中+有共享数据+多条语句操作共享数据。
五、同步锁
把有可能出现问题的代码包起来,一次只让一个线程执行。通过sychronized关键字实现同步。
当多个对象操作共享数据时,可以使用同步锁解决线程安全问题。
synchronized
synchronized(对象){
需要同步的代码;
}
特点
1、 前提1,同步需要两个或者两个以上的线程。
2、 前提2,多个线程间必须使用同一个锁。
3、 同步的缺点是会降低程序的执行效率, 为了保证线程安全,必须牺牲性能。
4、 可以修饰方法称为同步方法,使用的锁对象是this。
5、 可以修饰代码块称为同步代码块,锁对象可以任意。
案例:
public class TestThread3 {
public static void main(String[] args) {
Ticket3 t = new Ticket3();
Thread t1 = new Thread(t, "one");
Thread t2 = new Thread(t, "two");
Thread t3 = new Thread(t, "three");
Thread t4 = new Thread(t, "four");
t1.start(); // 调用了run方法,不是从Ticket3类从头开始执行,而是从run方法开始
t2.start();
t3.start();
t4.start();
}
}
class Ticket3 implements Runnable {
int tickets = 100;
Object obj = new Object();
public void run() {
while (true) {
// synchronized同步关键字,可以保证数据的安全,避免并发
// new Object()是锁对象,相当于给new Object()加了一把锁,线程拿钥匙来访问,没有钥匙的则等着。
// 加锁的位置:一定是多线程并发的开始位置
// new Object()加锁的对象不是同一个对象,每个线程都会创建自己的锁对象,线程之间是看不见的
// synchronized (new Object()) {
synchronized (obj) { // 或者把obj改成this,必须是同一个对象才可以
if (tickets > 0) {
try {
Thread.sleep(100);
} catch (InterruptedException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
System.out.println(Thread.currentThread().getName() + "卖票号:" + tickets--);
} else {
break;
}
}
}
}
}
六、线程创建的其他方式
ExecutorService/Executors
api
ExecutorService
execute(Runnable任务对象) 把任务丢到线程池
Executors 辅助创建线程池的工具类
newFixedThreadPool(5) 最多5个线程的线程池
newCachedThreadPool() 足够多的线程,使任务不必等待
newSingleThreadExecutor() 只有一个线程的线程池
案例:
//模拟线程池
//ExecutorService功能:提高多线程操作的读写效率,线程池里都是可运行的线程,不用new不用start,
//需要就拿走用,用完了会自动还回池子里,保证下个线程的使用,提高线程的可用性。
public class TestThread4 {
public static void main(String[] args) {
// 启动线程Thread.start()
// 1.创建线程池 -- 里面放的都是可运行状态的线程
// 2.通过线程池创建的工具类Executors,创建固定线程池newFixedThreadPool
ExecutorService pool = Executors.newFixedThreadPool(3);
// 3.用线程池干活execute(m)
// m是Runnable类型,为什么Thread4也可以,因为thread4是Runnable的接口孙子类
for (int i = 0; i < 10; i++) {
// pool.execute(new Thread4(i));
pool.execute(new MyRunnable(i));
}
}
}
//创建多线程的类方式1
class Thread4 extends Thread {
int i;
Thread4() {
}
Thread4(int i) {
this.i = i;
}
public void run() {
System.out.println(getName() + ":" + i);
}
}
//创建多线程的类方式2 -- 推荐!!
class MyRunnable implements Runnable {
int i;
MyRunnable() {
}
MyRunnable(int i) {
this.i = i;
}
@Override
public void run() {
// TODO Auto-generated method stub
System.out.println(Thread.currentThread().getName() + ":" + i);
}
}
Callable/Future
案例:
public class TestThread5 {
// 测试Callable实现多线程
public static void main(String[] args) throws InterruptedException, ExecutionException {
// 创建线程池对象
ExecutorService pool = Executors.newSingleThreadExecutor(); //创建一个线程池,里面只有一个线程
// 怎么执行call?? --ExucetorService.submit()
Future future = pool.submit(new MyCallable());
// 获取call()的返回值
Object o = future.get();
System.out.println(o);
}
}
class MyCallable implements Callable {
@Override
public Object call() throws Exception {
// TODO Auto-generated method stub
return new Random().nextInt(100);
}
}
Callable和Runnable的区别
Callable | Runnable |
---|---|
执行的是call()方法 方法有返回值 方法加了抛出异常 throws Exception | 执行的是run()方法 方法无返回值 |