进程和线程的概念
- 进程是一个动态的概念
a. 进程是程序的一次动态执行的过程,占用特定的地址空间。
b. 每个进程都是独立的,由三部分组cpu data code。
c. 缺点是浪费内存,cpu的负担。 - 线程是进程中的一个单一的连续控制流程/执行路径
a. 线程又被称为一个轻量级的进程。
b. 一个进程可以拥有多个并行的线程。
c. 一个进程中的线程共享相同的内存单元/内存地址空间,可以访问相同的变量和对象,而且他们从 同一堆中分配对象-通信、数据交换、同步操作。(容易造成并发)
d. 由于线程间的同信是在同一个地址空间进行的,所以不需要额外的通信机制,这就使得通信更 而且信息传递的速度也更快。
怎么模拟实现的多线程
cup调度的过程中有一个极短的时间片可以来回切换线程。
多线程的实现方式
1. 继承Thread类重写run()/线程体方法
缺点:Java只支持单进程如果我们的类继承了一个类那就无法再继承Thread类。
package com.company;
//继承THread类
public class thread extends Thread {
public void run(){
for(int i = 0; i < 100; i++){
System.out.println("兔子"+i);
}
}
}
class thread1 extends Thread {
public void run(){
for(int i = 0; i < 100; i++){
System.out.println("乌龟"+i);
}
}
}
package com.company;
//实现Thread调用stare方法才能实现线程的调度。
public class threadImplement {
public static void main(String[] args){
thread th = new thread();
thread1 th1 = new thread1();
th.start();
th1.start();
}
}
我们在程序里面调用了start()方法后,虚拟机会先为我们创建一个线程,然后等到这个线程第一次得到时间片时再调用run()方法。
注意不可多次调用start()方法。在第一次调用start()方法后,再次调用start()方法会抛出异常。
Thread类是一个Runnable接口的实现类,我们来看看Thread类的源码。
查看Thread类的构造方法,发现其实是简单调用一个私有的init方法来实现初始化。init的方法签名:
// Thread类源码
// 片段1 - init方法
private void init(ThreadGroup g, Runnable target, String name,
long stackSize, AccessControlContext acc,
boolean inheritThreadLocals)
// 片段2 - 构造函数调用init方法
public Thread(Runnable target) {
init(null, target, "Thread-" + nextThreadNum(), 0);
}
// 片段3 - 使用在init方法里初始化AccessControlContext类型的私有属性
this.inheritedAccessControlContext =
acc != null ? acc : AccessController.getContext();
// 片段4 - 两个对用于支持ThreadLocal的私有属性
ThreadLocal.ThreadLocalMap threadLocals = null;
ThreadLocal.ThreadLocalMap inheritableThreadLocals = null;
我们挨个来解释一下init方法的这些参数:
g:线程组,指定这个线程是在哪个线程组下; target:指定要执行的任务;
name:线程的名字,多个线程的名字是可以重复的。如果不指定名字,见片段2;
acc:见片段3,用于初始化私有变量inheritedAccessControlContext。
这个变量有点神奇。它是一个私有变量,但是在Thread类里只有init方法对它进行初始化,在exit方法把它设为null。其它没有任何地方使用它。一般我们是不会使用它的,那什么时候会使用到这个变量呢?可以参考这个stackoverflow的问题:Restrict
permissions to threads which execute third party software;
inheritThreadLocals:可继承的ThreadLocal,见片段4,Thread类里面有两个私有属性来支持ThreadLocal,我们会在后面的章节介绍ThreadLocal的概念。
实际情况下,我们大多是直接调用下面两个构造方法:
Thread(Runnable target)
Thread(Runnable target, String name)
2. 通过Runnable接口实现多线程
使用了静态代理模式,推荐使用runnable。
优点:避免单继承,方便共享资源,同一份资源多个代理访问。Runnable接口出现更符合面向对象,将线程单独进行对象的封装。
package com.company;
/*
* 使用Runnable创建线程(Thread类实现了Runnable接口)
* 1. 类实现runnable接口+重写run()-->真是角色
* 2. 启动多线程 使用静态代理
* */
public class runnable implements Runnable{
@Override
public void run() {
for (int i = 0 ;i < 100; i++){
System.out.println("天天"+ i);
}
}
}
package com.company;
public class runnabelImplement {
public static void main(String[] args) {
runnable ab = new runnable(); //创建真实角色类
Thread th = new Thread(ab); //创建代理角色并引用真实角色
th.start();
for (int i = 0 ;i < 100; i++){
System.out.println("hahah"+ i);
}
}
}
3. 实现Callable接口实现多线程
Callable与Runnable类似,同样是只有一个抽象方法的函数式接口。不同的是,Callable提供的方法是有返回值的,而且支持泛型。
优点:可以获取返回值,可以抛出异常,
缺点: 繁琐
思路:
1). 创建Callable实现类+重写call
2). 借助执行调度服务ExecutorService,获取Future对象
3). 获取值result.get()
4)停止服务ser.shutdownNow();
package com.company;
import java.util.concurrent.*;
/*
* 使用callable实现多线程
* */
public class Call {
public static void main(String[] args) throws ExecutionException, InterruptedException { //创建一个线程
ExecutorService ser = Executors.newFixedThreadPool(1);
Race ra = new Race();
//获取值
Future<Integer> result = ser.submit(ra);
int num = result.get();
System.out.println(num);
//停止服务
ser.shutdownNow();
}
}
class Race implements Callable<Integer> {
@Override
public Integer call() throws Exception {
return 1000;
}
}
线程的状态
- 初始(NEW):
新创建了一个线程对象,但还没有调用start()方法。
实现Runnable接口和继承Thread可以得到一个线程类,new一个实例出来,线程就进入了初始状态。 - 可运行(RUNNABLE):
Java线程中将就绪(ready)和运行中(running)两种状态笼统的称为“可运行”。
线程对象创建后,其他线程(比如main线程)调用了该对象的start()方法。该状态的线程位于可运行线程池中,等待被线程调度选中,获取CPU的使用权,此时处于就绪状态(ready)。就绪状态的线程在获得CPU时间片后变为运行中状态(running)。
就绪状态只是说你资格运行,调度程序没有挑选到你,你就永远是就绪状态。调用线程的start()方法,此线程进入就绪状态。当前线程sleep()方法结束,其他线程join()结束,等待用户输入完毕,某个线程拿到对象锁,这些线程也将进入就绪状态。当前线程时间片用完了,调用当前线程的yield()方法,当前线程进入就绪状态。锁池里的线程拿到对象锁后,进入就绪状态。 - 阻塞(BLOCKED):
当一个线程试图获取一个内部的对象锁,而该锁被其它线程持有,则该锁进入阻塞状态。 - 等待(WAITING):
当线程等待另一个线程通知调度器一个条件的时候,它自己进入等待状态。 - 计时等待(TIMED_WAITING):
该状态不同于WAITING,它可以在指定的时间后自行返回。如:join wait sleep 等 - 终止(TERMINATED):
表示该线程已经执行完毕。一个是因为run方法正常退出而自然死亡,一个是因为没有捕获异常终止了run方法而意外死亡。
线程进入等待的方法
- sleep()
sleep()方法需要指定等待的时间,它可以让当前正在执行的线程在指定的时间内暂停执行,进入等待状态,该方法既可以让其他同优先级或者高优先级的线程得到执行的机会,也可以让低优先级的线程得到执行机会。但是sleep()方法不会释放“锁标志”,也就是说如果有synchronized同步块,其他线程仍然不能访问共享数据。 - wait()
wait()方法需要和notify()及notifyAll()两个方法一起介绍,这三个方法用于协调多个线程对共享数据的存取,所以必须在synchronized语句块内使用,也就是说,调用wait(),notify()和notifyAll()的任务在调用这些方法前必须拥有对象的锁。注意,它们都是Object类的方法,而不是Thread类的方法。
wait()方法与sleep()方法的不同之处在于,wait()方法会释放对象的“锁标志”。当调用某一对象的wait()方法后,会使当前线程暂停执行,并将当前线程放入对象等待池中,直到调用了notify()方法后,将从对象等待池中移出任意一个线程并放入锁标志等待池中,只有锁标志等待池中的线程可以获取锁标志,它们随时准备争夺锁的拥有权。当调用了某个对象的notifyAll()方法,会将对象等待池中的所有线程都移动到该对象的锁标志等待池。
除了使用notify()和notifyAll()方法,还可以使用带毫秒参数的wait(long timeout)方法,效果是在延迟timeout毫秒后,被暂停的线程将被恢复到锁标志等待池。
此外,wait(),notify()及notifyAll()只能在synchronized语句中使用,但是如果使用的是ReenTrantLock实现同步,该如何达到这三个方法的效果呢?解决方法是使用ReenTrantLock.newCondition()获取一个Condition类对象,然后Condition的await(),signal()以及signalAll()分别对应上面的三个方法。 - yield()
yield()方法和sleep()方法类似,也不会释放“锁标志”,区别在于,它没有参数,即yield()方法只是使当前线程重新回到可执行状态,所以执行yield()的线程有可能在进入到可执行状态后马上又被执行,另外yield()方法只能使同优先级或者高优先级的线程得到执行机会,这也和sleep()方法不同。
package com.company;
public class yield extends Thread{
public static void main(String[] args) throws InterruptedException {
yield jo = new yield();
jo.start();
for (int i = 100 ; i>1 ; i--){
if(i%20==0){
Thread.yield(); //暂停本线程(main)
}
System.out.println("join"+i);
}
}
public void run(){
for (int i = 100 ; i>1 ; i--){
System.out.println("main"+i);
}
}
}
- join()
thread.Join()把指定的线程加入到当前线程,可以将两个交替执行的线程合并为顺序执行的线程。比如在线程B中调用了线程A的Join()方法,直到线程A执行完毕后,才会继续执行线程B。
package com.company;
public class join extends Thread {
public static void main(String[] args) throws InterruptedException {
join jo = new join();
Thread t = new Thread(jo);
t.start();
for (int i = 100 ; i>1 ; i--){
if(i==20){
t.join();
}
System.out.println("join"+i);
}
}
public void run(){
for (int i = 100 ; i>1 ; i--){
System.out.println("main"+i);
}
}
}