- 并行：指两个或多个事件在同一时刻发生（同时执行）。
- 并发：指两个或多个事件在同一个时间段内发生(交替执行)。
在 *** 作系统中，安装了多个程序，并发指的是在一段时间内宏观上有多个程序同时运行， 1.在单 CPU 系统中，每一时刻只能有一道程序执行，即微观上这些程序是分时的交替运行， 只不过是给人的感觉是同时运行，那是因为分时交替运行的时间是非常短的。 2.在多个 CPU 系统中，则这些可以并发执行的程序便可以分配到多个处理器上（CPU）， 实现多任务并行执行，即利用每个处理器来处理一个可以并发执行的程序，这样多个程序便可以同时执行。 目前电脑市场上说的多核 CPU，便是多核处理器，核越多，并行处理的程序越多，能大大的提高电脑运行的效率。1.2 线程与进程
- 进程：是指一个内存中运行的应用程序，每个进程都有一个独立的内存空间，一个应用程序可以同时运行多个进程；
进程也是程序的一次执行过程，是系统运行程序的基本单位；系统运行一个程序即是一个进程从创建、运行到消亡的过程。
什么是进程？
程序是静止的，运行中的程序就是进程。
进程的三个特征：
1.动态性 ： 进程是运行中的程序，要动态的占用内存，CPU和网络等资源。
2.独立性 ： 进程与进程之间是相互独立的，彼此有自己的独立内存区域。
3.并发性 ： 假如CPU是单核，同一个时刻其实内存中只有一个进程在被执行。
CPU会分时轮询切换依次为每个进程服务，因为切换的速度非常
快，给我们的感觉这些进程在同时执行，这就是并发性。
并行:同一个时刻同时有多个在执行。
- 线程：是进程中的一个执行单元，负责当前进程中程序的执行，一个进程中至少有一个线程。一个进程中是可以有多个线程的，
这个应用程序也可以称之为多线程程序。
什么是线程？
线程是属于进程的。一个进程可以包含多个线程，这就是多线程。
线程是进程中的一个独立执行单元。
线程创建开销相对于进程来说比较小。
线程也支持“并发性”。
线程的作用：
可以提高程序的效率，线程也支持并发性，可以有更多机会得到CPU。
多线程可以解决很多业务模型。
大型高并发技术的核心技术。
设计到多线程的开发可能都比较难理解。
2.创建线程
多线程是很有用的，我们在进程中创建线程的方式有三种:
（1）直接定义一个类继承线程类Thread，重写run()方法，创建线程对象
调用线程对象的start()方法启动线程。
（2）定义一个线程任务类实现Runnable接口，重写run()方法，创建线程任务对象，把
线程任务对象包装成线程对象， 调用线程对象的start()方法启动线程。
（3）实现Callable接口（拓展）。
2.1线程的创建方式一
public class ThreadDemo {
// 启动后的ThreadDemo当成一个进程。
// main方法是由主线程执行的，理解成main方法就是一个主线程
public static void main(String[] args) {
// 3.创建一个线程对象
Thread t = new MyThread();
// 4.调用线程对象的start()方法启动线程,最终还是执行run()方法！
t.start();
for(int i = 0 ; i < 100 ; i++ ){
System.out.println("main线程输出："+i);
}
}
}
// 1.定义一个线程类继承Thread类。
class MyThread extends Thread{
// 2.重写run()方法
@Override
public void run() {
// 线程的执行方法。
for(int i = 0 ; i < 100 ; i++ ){
System.out.println("子线程输出："+i);
}
}
}
继承Thread类的方式
-- 1.定义一个线程类继承Thread类。
-- 2.重写run()方法
-- 3.创建一个新的线程对象。
-- 4.调用线程对象的start()方法启动线程。
继承Thread类的优缺点：
优点：编码简单。
缺点：线程类已经继承了Thread类无法继承其他类了，功能不能通过继承拓展（单继承的局限性）
小结：
线程类是继承了Thread的类。
启动线程必须调用start()方法。
多线程是并发抢占CPU执行，所以在执行的过程中会出现并发随机性。
2.2注意事项
目标：线程的注意事项。
1.线程的启动必须调用start()方法。否则当成普通类处理。
-- 如果线程直接调用run()方法，相当于变成了普通类的执行，此时将只有主线程在执行他们！
-- start()方法底层其实是给CPU注册当前线程，并且触发run()方法执行
2.建议线程先创建子线程，主线程的任务放在之后。否则主线程永远是先执行完！
2.3线程的常用API.
Thread类的API:
1.public void setName(String name):给当前线程取名字。
2.public void getName():获取当前线程的名字。
-- 线程存在默认名称，子线程的默认名称是：Thread-索引。
-- 主线程的默认名称就是：main
3.public static Thread currentThread()
-- 获取当前线程对象，这个代码在哪个线程中，就得到哪个线程对象。
4. public static void sleep(long time): 让当前线程休眠多少毫秒再继续执行。
补充：除了用setName可以给线程取名字外还可以通过Thread类的有参数构造器为当前线程对象取名字
实现Runnable接口的方式。
-- 1.创建一个线程任务类实现Runnable接口。
-- 2.重写run()方法
-- 3.创建一个线程任务对象。
-- 4.把线程任务对象包装成线程对象
-- 5.调用线程对象的start()方法启动线程。
package com.itheima._15线程的创建_方式二;
public class ThreadDemo {
public static void main(String[] args) {
// 3.创建一个线程任务对象(注意：线程任务对象不是线程对象，只是执行线程的任务的)
Runnable target = new MyRunnable();
// 4.把线程任务对象包装成线程对象.且可以指定线程名称
// Thread t = new Thread(target);
Thread t = new Thread(target,"1号线程");
// 5.调用线程对象的start()方法启动线程
t.start();
Thread t2 = new Thread(target);
// 调用线程对象的start()方法启动线程
t2.start();
for(int i = 0 ; i < 10 ; i++ ){
System.out.println(Thread.currentThread().getName()+"==>"+i);
}
}
}
// 1.创建一个线程任务类实现Runnable接口。
class MyRunnable implements Runnable{
// 2.重写run()方法
@Override
public void run() {
for(int i = 0 ; i < 10 ; i++ ){
System.out.println(Thread.currentThread().getName()+"==>"+i);
}
}
}
利用匿名内部类的方式创建线程：
2.5线程的创建方式三（能够获取返回值）线程的创建方式三: 实现Callable接口。
-- 1,定义一个线程任务类实现Callable接口 ， 申明线程执行的结果类型。
-- 2,重写线程任务类的call方法，这个方法可以直接返回执行的结果。
-- 3,创建一个Callable的线程任务对象。
-- 4,把Callable的线程任务对象包装成一个未来任务对象。
-- 5.把未来任务对象包装成线程对象。
-- 6.调用线程的start()方法启动线程
package com.itheima._16线程的创建_方式三拓展;
import java.util.concurrent.Callable;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.FutureTask;
/**
拓展：线程的创建方式三。（拓展）
多线程是很有用的，我们在进程中创建线程的方式有三种:
（1）直接定义一个类继承线程类Thread，重写run()方法，创建线程对象
调用线程对象的start()方法启动线程。
（2）定义一个线程任务类实现Runnable接口，重写run()方法，创建线程任务对象，把
线程任务对象包装成线程对象， 调用线程对象的start()方法启动线程。
（3）实现Callable接口（拓展）。
c.线程的创建方式三: 实现Callable接口。
-- 1,定义一个线程任务类实现Callable接口 ， 申明线程执行的结果类型。
-- 2,重写线程任务类的call方法，这个方法可以直接返回执行的结果。
-- 3,创建一个Callable的线程任务对象。
-- 4,把Callable的线程任务对象包装成一个未来任务对象。
-- 5.把未来任务对象包装成线程对象。
-- 6.调用线程的start()方法启动线程
优缺点：
优点：全是优点。
-- 线程任务类只是实现了Callable接口，可以继续继承其他类，而且可以继续实现其他接口（避免了单继承的局限性）
-- 同一个线程任务对象可以被包装成多个线程对象
-- 适合多个多个线程去共享同一个资源（后面内容）
-- 实现解耦 *** 作，线程任务代码可以被多个线程共享，线程任务代码和线程独立。
-- 线程池可以放入实现Runable或Callable线程任务对象。(后面了解)
-- 能直接得到线程执行的结果！
缺点：编码复杂。
*/
public class ThreadDemo {
public static void main(String[] args) {
// 3.创建一个Callable的线程任务对象
Callable call = new MyCallable();
// 4.把Callable任务对象包装成一个未来任务对象
// -- public FutureTask(Callable callable)
// 未来任务对象是啥，有啥用？
// -- 未来任务对象其实就是一个Runnable对象:这样就可以被包装成线程对象！
// -- 未来任务对象可以在线程执行完毕之后去得到线程执行的结果。
FutureTask task = new FutureTask<>(call);
// 5.把未来任务对象包装成线程对象
Thread t = new Thread(task);
// 6.启动线程对象
t.start();
for(int i = 1 ; i <= 10 ; i++ ){
System.out.println(Thread.currentThread().getName()+" => " + i);
}
// 在最后去获取线程执行的结果,如果线程没有结果，让出CPU等线程执行完再来取结果
try {
String rs = task.get(); // 获取call方法返回的结果（正常/异常结果）
System.out.println(rs);
} catch (Exception e) {
e.printStackTrace();
}
}
}
// 1.创建一个线程任务类实现Callable接口，申明线程返回的结果类型
class MyCallable implements Callable{
// 2.重写线程任务类的call方法！
@Override
public String call() throws Exception {
// 需求：计算1-10的和返回
int sum = 0 ;
for(int i = 1 ; i <= 10 ; i++ ){
System.out.println(Thread.currentThread().getName()+" => " + i);
sum+=i;
}
return Thread.currentThread().getName()+"执行的结果是："+sum;
}
}
欢迎分享，转载请注明来源：内存溢出
微信扫一扫
支付宝扫一扫
评论列表（0条）