程序 :
是为完成特定任务,用某种语言编写的一组指令的集合.即指一段静态的代码
进程:
概念:程序的一次执行过程,或是正在运行的一个程序
说明:进程作为资源分配的单位,系统在运行时会为每个进程分配不同的内存区域
线程:
概念:进程可进一步细化为线程,是一个程序内部的一条执行语句路径
说明:线程作为调度和执行的单位,每个线程拥有独立的运行栈和程序计数器(pc),线程切换的开销小内存结构:
单核CPU与多核CPU的理解:
单核CPU其实是一种假的多线程,因为在一个时间单元内,也只能执行一个线程任务.
多核才能更好的发挥多线程的效率
并行与并发的理解:
并行:多个CPU同时执行多个任务.比如:多个人同时做不同的事
并发:一个CPU(采用时间片)同时执行多个任务.比如:秒杀,多个人做同一件事
创建多线程的两种方式
方式一:
- 创建一个继承于Thread类的子类
- 重写 Thread类的run() --->将此线程执行的操作声明在run()中
- 创建Thread类的子类的对象
- 通过此对象调用start()
说明:
我们启动一个线程,必须调用start(),不能调用run()的方式启动线程
如果再启动一个线程,必须重新创建一个Thread子类的对象,调用此对象的start()
方式二:实现Runnable接口的方式:
- 创建一个实现了Runnable接口的类
- 实现类去实现Runnable中的抽象方法:run()
- 创建实现类的对象
- 将此对象作为参数传递到Thread类的构造器中,创建Thread类的对象
- 通过Thread类的对象调用start()
两种方式的对比:
开发中:优先选择:实现Runnable接口的方式
原因:
- 实现的方式没类的单继承性的局限性
- 实现的方式更适合来处理多个线程共享数据的情况
联系:public class Thread implements Runnable
相同点:两种方式都需要重写run(),将线程要执行的逻辑声明在run()中
目前两种方式想要启动线程,都是调用的Thread类中的start()
Thread类中的常用方法:
- start():启动当前线程;调用当前线程的run()
- run():通常需要重写Thread类中的此方法,将创建的线程要执行的操作声明在此方法中
- currentThread():静态方法,返回执行当前代码的线程
- getName():获取当前线程的名字
- setName():设置当前线程的名字
- yield():释放当前cpu的执行权
- join():在线程a中调用线程b的join(),此时线程a就进入阻塞状态,直到线程b完全执行完以后,线程a才结束阻塞状态
- stop():已过时.当执行此方法时,强制借宿当前线程
- sleep(long millitime):让当前线程"睡眠"指定的millitiome毫秒.在指定的millitime毫秒时间内,当前线程是阻塞状态
- isAlive():判断当前线程是否存活
线程优先级:
1.MAX_PRIORITY:10
MIN_PRIORITY:1
NORM_PRIORITY:5 --->默认优先级
2.和获取和设置当前线程的优先级
getPriority():获取线程的优先级
setPriority(int p):设置线程的优先级
说明:高优先级的 线程要抢占低优先级线程cpu的执行权.但是只是从概念上讲,高优先级的线程高概率的 情况下被执行.并不意味着只当高优先级的线程执行完以后,低优先级的线程才执行.
线程通信:wait() / notify() /notifyAll() :此两个方法定义在Object类中的
Thread生命周期
说明:
- 生命周期关注两个概念:状态 ,相应的方法
- 关注:状态a--->状态b:哪些方法执行了(回调方法)
某个方法主动调用:状态a--->状态b
3.阻塞:临时状态,不可以作为最终状态
死亡:最终状态
线程同步机制
在Java中,我们通过同步机制,来解决线程的安全问题
方式一:同步 代码块
synchronized(同步监视器){
//需要被同步的代码
}
说明:
- 操作共享数据的代码,即为需要被同步的代码.--->不能包含代码多了,也不能包含 代码少了
- 共享数据:多个线程共同操作的变量.比如:ticket结束共享数据
- 同步监视器,俗称:锁.任何一个类的对象都可以充当锁
要求:多个线程必须要共用同一把锁
补充:在实现Runnable接口创建多线程的方式中 ,我们可以考虑使用this充当同步监视器
在继承Thread类创建多线程的方式中,慎用this充当同步监视器,考虑使用当前类充当同步监视器
方式二:同步方法
如果操作共享数据的代码完整的声明在一个方法中,我们不妨将此方法声明同步的
关于同步方法的总结:
- 同步方法仍然涉及到同步监视器,只是不需要我们显示的声明
- 非静态的同步方法,同步监视器是:this 静态同步方法,同步监视器是:当前类本身
方式三:lock锁 ---->JDK5.0新增
面试题:synchronized与lock的异同?
相同:二者都可以解决线程安全问题
不同:synchronized机制在执行完相应的同步代码以后,自动的释放同步监视器
lock需要手动的启动同步(lock(),同时结束同步也需要手动的实现unlock())
使用的优先顺序:
lock -->同步代码块(已经进入方法体,分配了相应资源) --->同步方法 (在方法体之外)
利弊:
利:同步的方式,解决了线程的安全问题
弊:操作同步代码时,只能一个线程参与,其他线程等待.相当于是一个单线程的过程,效率低
死锁的理解:不同的线程分别占用对方需要的同步资源不放弃,都在等待对方放弃自己需要的同步资源,就形成了线程的死锁
说明:1.出现死锁后,不会出现一次,不会出现提示,只是所有的线程都处于阻塞状态,无法继续
2.我们使用同步时,要避免出现死锁
线程通信
线程通信涉及到的三个方法:
wait():一旦执行此方法,当前线程就进入阻塞状态,并释放同步监视器
notify():一旦执行此方法,就会唤醒被wait的一个线程.如果有多个线程被wait,就唤醒优先级高的那个
notifyAll():一旦执行此方法,就会唤醒所有被wait的线程
说明:
1.wait() notify() notifyAll()个方法必须使用在同步代码块或同步方法中
2.wait() notify() notifyAll()个方法调用者必须是同步代码块或同步方法中的同步监视器,否则,会出现IllegalMonitorStateException异常
3.wait() notify() notifyAll()个方法是定义在java.lang.Object类中
面试题:sleep() 和wait()的异同?
相同:一旦执行方法,都可以使得当前的线程进入阻塞状态.
不同点:1.两个方法声明位置不同:Thread类 中声明sleep(),Object类中 声明wait()
2.调用的要求不同:sleep()可以在任何需要的场景下调用.wait()必须使用在同步代码块或同步方法中
3.关于是否释放同步监视器:如果两个方法都使用在同步代码块或同步方法中,sleep()不会释放锁,wait()会释放锁
释放锁操作:
不会释放锁的操作
JDK5.0新增线程创建的方式
新增方式一:实现Callable接口. --- JDK 5.0新增
//1.创建一个实现Callable的实现类
class NumThread implements Callable{
//2.实现call方法,将此线程需要执行的操作声明在call()中
@Override
public Object call() throws Exception{
int sum = 0;
for(int i = 1; i <= 100; i++){
if(i % 2 == 0){
System.out.println(i);
sum += i;
}
}
return sum;
}
}
pubic class ThreadNew{
public static void mian(String[] args){
//3.创建 Callable接口实现类的对象
NumThread numThread = new NumThread();
//4.将此Callable 接口实现类的对象作为传递到FutureTask构造器中,创建FutureTask的对象
FutureTask futureTask = new FutureTask(numThread);
//5.将FutureTask的对象作为参数传递到Thread类的构造器中,创建Thread对象,并调用start()
new Thread(futureTask).start();
try{
//6.获取Callable中call方法的返回值
//get()返回值即为FutureTask构造器参数Callable实现类重写的call()的返回值
Object sum = futureTask.get();
System.out.println("总和:" + sum);
}catch(InterruptedException e){
e.printStackTrace();
}catch(ExecutionException e){
e.printStackTrace();
}
}
}
说明:如何理解实现Callable接口的方式创建多线程比实现Runnable接口创建多线程方式强大?
- call()可以返回值的
- call()可以抛出异常,被外面操作捕获,获取异常的信息
- Callable是支持泛型的
新增方式二:使用线程池
class NumberThread implements Runnable{
@Override
public void run(){
for(int i = 0;i <= 100 ;i++){
if(i % 2 == 0){
System.out.println(Thread.currentThread().getName() +":" + i);
}
}
}
}
class NumberThread1 implements Runnable{
@Override
public void run(){
for(int i = 0;i <= 100 ;i++){
if(i % 2 == 0){
System.out.println(Thread.currentThread().getName() +":" + i);
}
}
}
}
public class ThreadPool{
public static void mian(String[] args){
//1/提供指定线程数量的线程池
ExecutorService service = Executors.newFixedThreadPool(10);
ThreadPoolExecutor service1 = (ThreadPoolExecutor)service;
//设置线程池的属性
//System.out.println(service.getClass());
//service.setCorePoolSize(15);
//servicel.setKeepAliveTime();
//2.执行指定的线程的操作,需要提供实现Runnable接口或Callable接口实现类的对象
service.execute(new NumberThread());//适合 适用于Runnable
service.execute(new NumberThread());//适合适用于Runnable
//service.submit(Callable callable);//适合使用于Callable
//3.关闭连接池
service.shutdown();
}
}
线程池说明:好处:
- 提高响应速度减少了创建新线程的时间
- 降低资源消耗(重复利用线程池中线程,不需要每次都创建)
- 便于线程管理
corePoolSize:核心池的大小
maximumPoolSize:最大线程数
keepAliveTime:线程没任务时最多保持多长时间后会终止
扫一扫
15万+
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
