进程和线程的区别
进程:是指运行后的程序,是操作系统分配系统资源(内存空间、CPU)的最小单位。
线程:每个进程由一个或者多个进程组成,线程是CPU进行分配和调度的最小单位。
1.内存方面:
进程需要的资源更多(堆、方法区、本地方法区),线程更轻量级(栈、程序计数器)。
线程共享所在进程的内存空间(堆、方法区、本地方法区)。
2.创建和销毁以及上下文切换:
进程需要更多时间和资源,线程更快。
3.相互通信方面:
进程之间的通信比较麻烦(RPC、网络),线程之间通信更容易(通过进程共享的内存空间)。
浅谈并行和并发
一个CPU内核一个时间段只能运行一个线程的指令,因为CPU执行的速度特别快所以感觉多个程序同时运行 。
并发:一个CPU在多个线程间来回切换执行,不是真正同时执行。
并行:多个CPU同时执行多个线程,是真正同时执行。
多线程的作用和应用场景
线程是程序指令的单独的执行路径,多线程同时执行,大大提高了程序的执行效率。
应用场景:
1.多线程下载
2.游戏(图形绘制、游戏控制、网络通信。。)
3.互联网应用(服务器为每个用户单独开线程,相互不影响)。
线程的三种实现方式
1.继承Thread类
步骤:定义类继承Thread类,然后重写run方法,创建线程对象,调用start()方法。
/**
* 使用Thread类实现自定义线程
*/
public class MyThread extends Thread{
@Override
public void run() {
for (int i = 0; i <100 ; i++) {
System.out.println(Thread.currentThread().getName()+"-------"+i);
}
}
public static void main(String[] args) {
MyThread myThread = new MyThread();
//启动线程thread
myThread.start();
//主线程main
// myThread.run();
for (int i = 0; i <100 ; i++) {
System.out.println(Thread.currentThread().getName()+"-------"+i);
}
}
}
疑问1: 执行run()和start()有什么区别?
调用run()方法是在主线程同步执行的,调用start后才会 启动新线程去执行。
疑问2:如果调用两次start会怎么样?
会抛出异常IllegalThreadStateException,线程是一次性的,不允许执行两次。
疑问3:多线程的执行顺序是怎么样?
多线程的执行是抢占式的,线程会去抢占CPU,抢到后执行自己的指令,执行过程中CPU可能被其它线程抢占,其它线程执行。
疑问4:上下文切换回原来的线程时,如何执行从哪里开始执行?
每个线程有自己的程序计数器,保存当前线程执行的行数,切换回来后继续执行下面的行代码。
2.实现Runnable接口
步骤:1.定义类实现Runnable接口,2.实现run方法,3.创建Thread对象,传入Runnable,调用start方法。
/**
* 使用Runnable接口实现自定义线程
*/
public class MyRunable implements Runnable {
@Override
public void run() {
for (int i = 0; i <100 ; i++) {
System.out.println(Thread.currentThread().getName()+"-------"+i);
}
}
public static void main(String[] args) {
//创建MyRunable对象,创建Thread对象
MyRunable myRunable = new MyRunable();
Thread thread = new Thread(myRunable);
thread.start();
//匿名内部类写法
Thread thread1 = new Thread(new Runnable(){
@Override
public void run() {
for (int i = 0; i <100 ; i++) {
System.out.println(Thread.currentThread().getName()+"-------"+i);
}
}
});
thread1.start();
//lambda表达式写法
Thread thread2 = new Thread(()->{
for (int i = 0; i <100 ; i++) {
System.out.println(Thread.currentThread().getName()+"-------"+i);
}
});
thread2.start();
}
}
疑问:继承Thread类和实现Runnable两种方式的区别?
解答:1.Java是单继承的,继承Thread类就不能继承其它类,实现接口没有此限制。
2. 继承Thread不强制要求重写run,实现Runnable强制要求。
3.Runnable可以使用Lambda表达式,语法简介。
推荐使用Runnable方式。
3.实现Callable接口
使用Thread类和Runnable类都是没有返回值的,如果想要有返回值,可以使用Callable。
步骤:1.实现Callable接口,重写call()方法,2.创建一个FutureTask对象传入Callable实现对象,3.创建Thread线程传入FutureTask对象,4.启动线程,5.通过FutureTask的get()方法获取返回值。
/**
* 使用Callable接口自定义一个线程
*/
public class MyCallable implements Callable<Long> {
@Override
public Long call() throws Exception {
long sum = 0;
for (int i = 0; i <100000 ; i++) {
sum += i;
}
return sum;
}
public static void main(String[] args) {
//创建FutureTask对象,传入Callable对象
FutureTask<Long> futureTask = new FutureTask<Long>(new MyCallable());
//创建Thread对象,传入FutureTask对象
Thread thread = new Thread(futureTask);
//启动线程
thread.start();
try {
//获取返回值
Long value = futureTask.get();
System.out.println(value);
} catch (InterruptedException e) {
e.printStackTrace();
} catch (ExecutionException e) {
e.printStackTrace();
}
}
}
线程的生命周期
线程常用的方法:
start() 启动线程
stop() 停止线程
setName(String) 设置名字
getName() 获得名字
sleep(long) 睡眠
suspend() 挂起线程
resume() 恢复线程
yield() 放弃执行
join() 合并线程
setPriority(int) 设置线程优先级
setDaemon(boolean) 设置后台线程
停止线程
如果使用 stop() 调用stop会停止线程,不会释放锁,可能导致死锁,一般是禁用stop。
停止线程的办法:1.等待run执行完。2. 在run执行代码中加入条件,中途停止执行。
线程的睡眠
Thread类的静态方法 sleep(毫秒数)
Thread.sleep(毫秒) 阻塞住当前线程,当时间结束后线程自动唤醒
疑问:wait和sleep的区别?
解答:1.调用对象不同: wait是锁对象调用,sleep是当前线程调用。
2.唤醒机制不同: 线程进入wait后,要通过锁对象notify/notifyAll唤醒,sleep当时间结束自动唤醒。
3.锁释放不同:线程进入wait后,会自动释放锁,线程sleep不会释放锁。
线程的优先级
线程有优先级从低到高分为1~10,默认是5,线程优先级越高抢到CPU的几率越高,可以给执行更重要任务的线程设置更高的优先级。
Thread thread1 = new Thread(() -> {
for (int i = 0; i < 100; i++) {
System.out.println(Thread.currentThread().getName() + "-->" + i);
}
});
Thread thread2 = new Thread(() -> {
for (int i = 0; i < 100; i++) {
System.out.println(Thread.currentThread().getName() + "-->" + i);
}
});
//设置优先级
thread2.setPriority(Thread.MAX_PRIORITY);
thread1.setPriority(Thread.MIN_PRIORITY);
thread1.start();
thread2.start();
后台线程
后台线程也叫守护线程(精灵线程),后台线程的任务是为其它线程提供服务,当其它线程都死亡后,后台线程会自动死亡。
使用:setDaemon(true) 设置后台线程
应用场景:gc线程(垃圾收集器)就是典型的后台线程。
/**
* 守护线程
*/
public class DaemonDemo {
public static void main(String[] args) {
Thread daemon = new Thread(()->{
for (int i = 0; ; i++) {
System.out.println(Thread.currentThread().getName()+"-------"+i);
try {
Thread.sleep(1000);
} catch (InterruptedException e) {
e.printStackTrace();
}
}
});
//设置守护线程
daemon.setDaemon(true);
daemon.setName("守护线程");
daemon.start();
//被守护线程
for (int i = 0; i < 3 ; i++) {
Thread thread =new Thread(()->{
for (int j = 0; j < 10 ; j++) {
System.out.println(Thread.currentThread().getName()+"-------"+j);
try {
Thread.sleep(1000);
} catch (InterruptedException e) {
e.printStackTrace();
}
}
});
thread.start();
}
}
}
合并线程
线程的执行是抢占式的,在线程内部可以合并其它线程,让其它线程的执行代码在当前线程前面执行,然后执行自己的指令。
/**
* 合并线程
*/
public class JoinDemo {
static Thread thread1=null,thread2=null;
public static void main(String[] args) {
thread1 = new Thread(()->{
for (int i = 0; i <10; i++) {
System.out.println(Thread.currentThread().getName()+"-------"+i);
try {
//合并线程
// if(i==5){
// thread2.join();
// }
Thread.sleep(1000);
} catch (InterruptedException e) {
e.printStackTrace();
}
}
});
thread1.setName("合并线程1");
thread1.start();
thread2 = new Thread(()->{
for (int i = 0; i <10; i++) {
System.out.println(Thread.currentThread().getName()+"-------"+i);
try {
if (i==5){
//合并线程
thread1.join();
}
Thread.sleep(1000);
} catch (InterruptedException e) {
e.printStackTrace();
}
}
});
thread2.setName("合并线程2");
thread2.start();
}
}
本文内容由网友自发贡献,版权归原作者所有,本站不承担相应法律责任。如您发现有涉嫌抄袭侵权的内容,请联系:hwhale#tublm.com(使用前将#替换为@)