脚本宝典收集整理的这篇文章主要介绍了进程与线程,脚本宝典觉得挺不错的,现在分享给大家,也给大家做个参考。
进程就是正在运行的程序,它会占用对应的内存区域,由CPU进行执行与计算。
线程是操作系统OS能够进行运算调度的最小单位,它被包含在进程之中,是进程中的实际运作单位. 一个进程可以开启多个线程,其中有一个主线程来调用本进程中的其他线程。 我们看到的进程的切换,切换的也是不同进程的主线程 多线程可以让同一个进程同时并发处理多个任务,相当于扩展了进程的功能。
一个操作系统中可以有多个进程,一个进程中可以包含一个线程(单线程程序),也可以包含多个线程(多线程程序)
我们宏观上觉得多个进程是同时运行的,但实际的微观层面上,一个CPU【单核】只能执行一个进程中的一个线程。 那为什么看起来像是多个进程同时执行呢F1f; 是因为CPU以纳秒级别甚至是更快的速度高效切换着,超过了人的反应速度,这使得各个进程从看起来是同时进行的,也就是说,宏观层面上,所有的进程看似并行【同时运行】,但是微观层面上是串行的【同一时刻,一个CPU只能处理一件事】。
串行是指同一时刻一个CPU只能处理一件事,类似于单车道 并行是指同一时刻多个CPU可以处理多件事,类似于多车道
时间片,即CPU分配给各个线程的一个时间段,称作它的时间片,即该线程被允许运行的时间,如果在时间片用完时线程还在执行,那CPU将被剥夺并分配给另一个线程,将当前线程挂起,如果线程在时间片用完之前阻塞或结束,则CPU当即进行切换,从而避免CPU资源浪费,当再次切换到之前挂起的线程,恢复现场,继续执行。 注意:我们无法控制OS选择执行哪些线程,OS底层有自己规则,如:
由于线程状态比较复杂,我们由易到难,先学习线程的三种基础状态及其转换,简称”三态模型” :
就绪 → 执行:为就绪线程分配CPU即可变为执行状态" 执行 → 就绪:正在执行的线程由于时间片用完被剥夺CPU暂停执行,就变为就绪状态 执行 → 阻塞:由于发生某事件,使正在执行的线程受阻,无法执行,则由执行变为阻塞 (例如线程正在访问临界资源,而资源正在被其他线程访问) 反之,如果获得了之前需要的资源,则由阻塞变为就绪状态,等待分配CPU再次执行
我们可以再添加两种状态:
PCB(PRocess Control Block):为了保证参与并发执行的每个线程都能独立运行,OS配置了特有的数据结构PCB来描述线程的基本情况和活动过程,进而控制和管理线程
处于就绪(可运行)状态的线程,只是说明线程已经做好准备,随时等待CPU调度执行,并不是执行了t.start()此线程立即就会执行
就绪状态是进入运行状态的唯一入口,也就是线程想要进入运行状态状态执行,先得处于就绪状态
Thread类本质上是实现了Runnable接口的一个实例,代表一个线程的实例 启动线程的唯一方法就是通过Thread类的start()实例方法 start()方法是一native方法,它将通知底层操作系统,.最终由操作系统启动一个新线程,操作系统将执行run() 这种方式实现的多线程很简单,通过自己的类直接extends Thread,并重写run()方法,就可以自动启动新线程并执行自己定义的run()方法 模拟开启多个线程,每个线程调用run()方法.
构造方法
Thread() 分配新的Thread对象 Thread(String name) 分配新的Thread对象 Thread(Runnable target) 分配新的Thread对象 Thread(Runnable target,String name) 分配新的Thread对象
static Thread currentThread( ) 返回对当前正在执行的线程对象的引用 long getId() 返回该线程的标识 String getName() 返回该线程的名称 void run() 如果该线程是使用独立的 Runnable 运行对象构造的,则调用该 Runnable 对象的 run 方法 static void sleep(long millions) 在指定的毫秒数内让当前正在执行的线程休眠(暂停执行) void start() 使该线程开始执行:Java虚拟机调用该线程的run()
创建包: cn.tedu.thread 创建类: testThread1.java
package cn.tedu.thread;
/*本类用于多线程编程实现方案一:继承Thread类来完成*/
public class TestThread1 {
public static void main(String[] args) {
//4.创建线程对象进行测试
/*4.new对应的是线程的新建状态
* 5.要想模拟多线程,至少得启动2个线程,如果只启动1个,是单线程程序*/
MyThread t1 = new MyThread();
MyThread t2 = new MyThread();
MyThread t3 = new MyThread();
MyThread t4 = new MyThread();
/*6.这个run()如果直接这样调用,是没有多线程抢占执行的效果的
* 只是把这两句话看作普通方法的调用,谁先写,就先执行谁*/
//t1.run();
//t2.run();
/*7.start()对应的状态就是就绪状态,会把刚刚新建好的线程加入到就绪队列之中
* 至于什么时候执行,就是多线程执行的效果,需要等待OS选中分配CPU
* 8.执行的时候start()底层会自动调用我们重写的run()种的业务
* 9.线程的执行具有随机性,也就是说t1-t4具体怎么执行
* 取决于CPU的调度时间片的分配,我们是决定不了的*/
t1.start();//以多线程的方式启动线程1,将当前线程变为就绪状态
t2.start();//以多线程的方式启动线程2,将当前线程变为就绪状态
t3.start();//以多线程的方式启动线程3,将当前线程变为就绪状态
t4.start();//以多线程的方式启动线程4,将当前线程变为就绪状态
}
}
//1.自定义一个多线程类,然后让这个类继承Thread
class MyThread extends Thread{
/*1.多线程编程实现的方案1:通过继承Thread类并重写run()来完成的 */
//2.重写run(),run()里是我们自己的业务
@override
public void run() {
/*2.suPEr.run()表示的是调用父类的业务,我们现在要用自己的业务,所以注释掉*/
//super.run();
//3.完成业务:打印10次当前正在执行的线程的名称
for (int i = 0; i < 10; i++) {
/*3.getName()表示可以获取当前正在执行的线程名称
* 由于本类继承了Thread类,所以可以直接使用这个方法*/
System.out.println(i+"="+getName());
}
}
}
如果自己的类已经extends另一个类,就无法多继承,此时,可以实现一个Runnable接口
void run()使用实现接口Runnable的对象创建线程时,启动该线程将导致在独立执行的线程中调用对象的run()方法
创建包: cn.tedu.thread 创建类: Thread2.java
package cn.tedu.thread;
/*本类用于多线程编程实现方案二:实现Runnable接口来完成*/
public class TestThread2 {
public static void main(String[] args) {
//5.创建自定义类的对象--目标业务类对象
MyRunnable target = new MyRunnable();
//6.如何启动线程?自己没有,需要与Thread建立关系
Thread t1 = new Thread(target);
Thread t2 = new Thread(target);
Thread t3 = new Thread(target);
Thread t4 = new Thread(target);
t1.start();
t2.start();
t3.start();
t4.start();
}
}
//1.自定义多线程类
class MyRunnable implements Runnable{
//2.添加父接口中的抽象方法run(),里面是自己的业务
@Override
public void run() {
//3.写业务,打印10次当前正在执行的线程名称
for (int i = 0; i < 10; i++) {
/*问题:自定义类与父接口Runnable中都没有获取名字的方法
* 所以还需要从Thread中找:
* currentThread():静态方法,获取当前正在执行的线程对象
* getName():获取当前线程的名称*/
System.out.println(i+"="+Thread.currentThread().getName());
}
}
}
需求:设计4个售票窗口,总计售票100张。用多线程的程序设计并写出代码
创建包: cn.tedu.tickets 创建类: TestThread.java
package cn.tedu.tickets;
/*需求:设计多线程编程模型,4个窗口共计售票100张
* 本方案使用多线程编程方案1,继承Thread类的方式来完成*/
public class TestThread {
public static void main(String[] args) {
//5.创建多个线程对象
TicketThread t1 = new TicketThread();
TicketThread t2 = new TicketThread();
TicketThread t3 = new TicketThread();
TicketThread t4 = new TicketThread();
//6.以多线程的方式启动
t1.start();
t2.start();
t3.start();
t4.start();
}
}
//1.自定义多线程售票类,继承Thread
class TicketThread extends Thread{
//3.定义变量,保存要售卖的票数
/*问题:4个线程对象共计售票400张,原因是创建了4次对象,各自操作各自的成员变量
* 解决:让所有对象共享同一个数据,票数需要设置为静态*/
static int tickets = 100;
//2.重写父类的run(),里面是我们的业务
@Override
public void run() {
//4.1循环卖票
while(true){
try {
//7.让每个线程经历休眠,增加线程状态切换的频率与出错的概率
//问题1:产生了重卖的现象:同一张票卖了多个人
//问题2:产生了超卖的现象:超出了规定的票数100,出现了0 -1 -2这样的票
Thread.sleep(10);//让当前线程休眠10ms
} catch (InterruptedException e) {
e.printStackTrace();
}
//4.2打印当前正在卖票的线程名称,并且票数-1
System.out.println(getName()+"="+tickets--);
//4.3做判断,如果没有票了,就退出死循环
if(tickets <= 0) break;//注意,死循环一定要设置出口
}
}
}
创建包: cn.tedu.tickets 创建类: TestRunnable.java
package cn.tedu.tickets;
/*需求:设计多线程编程模型,4个窗口共计售票100张
* 本方案使用多线程编程方案2,实现Runnable接口的方式来完成*/
public class TestRunnable {
public static void main(String[] args) {
//5.创建Runnable接口的实现类对象,作为目标业务对象
TicketRunnable target = new TicketRunnable();
//6.创建多个Thread类线程对象,并将target业务对象交给多个线程对象来处理
Thread t1 = new Thread(target);
Thread t2 = new Thread(target);
Thread t3 = new Thread(target);
Thread t4 = new Thread(target);
//7.以多线程的方式启动多个线程对象
t1.start();
t2.start();
t3.start();
t4.start();
}
}
//1.自定义多线程类实现Runnable接口
class TicketRunnable implements Runnable{
//3.定义一个成员变量,用来保存票数100
/*由于自定义类对象只创建了一次,所以票数被所有线程对象Thread类的对象共享*/
int tickets = 100;
//2.添加接口中未实现的方法,方法里是我们的业务
@Override
public void run() {
//4.1循环卖票
while(true){
//8.让线程休眠10ms,增加线程状态切换的概率和出错的概率
try {
Thread.sleep(10);//让当前线程休眠10ms
} catch (InterruptedException e) {
e.printStackTrace();
}
//4.2打印当前正在售票的线程名称 & 票数-1
System.out.println(Thread.currentThread().getName()+"="+tickets--);
//4.3设置死循环的出口,没票了就停止卖票
if(tickets <=0 ) break;
}
}
}
以上是脚本宝典为你收集整理的进程与线程全部内容,希望文章能够帮你解决进程与线程所遇到的问题。
本图文内容来源于网友网络收集整理提供,作为学习参考使用,版权属于原作者。
如您有任何意见或建议可联系处理。小编QQ:384754419,请注明来意。