精华内容
下载资源
问答
  • 线程:CPU调度的最小单位,一个进程至少有一个线程。 举个例子:我们的计算机是个大型的地铁乘换中心,每一个进程是在通道上的地铁。而线程则是组成地铁的车厢。一台地铁至少有一个车厢才能称之为地铁,当然也不能...

    进程和线程

    进程:资源分配的最小单位,这举例子就是windows上最小单元便是进程。我们平常执行的exe等文件在计算机上的表现便是进程。
    线程:CPU调度的最小单位,一个进程中至少有一个线程。
    举个例子:我们的计算机是个大型的地铁乘换中心,每一个进程是在通道上的地铁。而线程则是组成地铁的车厢。一台地铁至少有一个车厢才能称之为地铁,当然也不能无限多的线程(理论最多上线程为2048)。

    线程的几种状态

    话不多说,上源码
    在这里插入图片描述
    在这里插入图片描述
    线程状态:新建,阻塞,等待,超时等待,超时结束。(Java源码里的,不接受反驳)
    此处解释下sleep和wati的区别,其实两这最大的区别就是sleep睡着了,抱着锁未释放,而wait则会释放锁,等待别人再次给你锁。(名词很形象)

    Java中的线调用Thread调用

    这是Java中调用Thread的方法,从这可以看出。java实际上并不是真正的可以创建线程。它是调用本地的start0去启动线程组中的线程,而statrt0这个方法则是调用本地线程。
    源码中
    native这个关键字说明为:一个Native Method就是一个java调用非java代码的接口。一个Native Method是这样一个java的方法:该方法的实现由非java语言实现,比如C。这个特征并非java所特有,很多其它的编程语言都有这一机制,比如在C++中,你可以用extern "C"告知C++编译器去调用一个C的函数。
    “A native method is a Java method whose implementation is provided by non-java code.”
    在这里插入图片描述
    从这看出java实际上是使用别的非java接口去创建线程,他本身无法创建线程。

    展开全文
  • 每个程序程序都至少有一个线程,也即是程序本身。 2.线程状态 Java语言定义了5种线程状态,在任意一个时间点,一个线程只能有且只有其中一个状态。,这5种状态如下: (1)新建(New):创建后尚未启动的线程处于...

    1.线程是什么?

        线程被称为轻量级进程,是程序执行的最小单位,它是指在程序执行过程中,能够执行代码的一个执行单位。每个程序程序都至少有一个线程,也即是程序本身。
    

    2.线程状态

        Java语言定义了5种线程状态,在任意一个时间点,一个线程只能有且只有其中一个状态。,这5种状态如下:
    

    (1)新建(New):创建后尚未启动的线程处于这种状态

    (2)运行(Runable):Runable包括了操作系统线程状态的Running和Ready,也就是处于此状态的线程有可能正在执行,也有可能正在等待着CPU为它分配执行时间。

    (3)等待(Wating):处于这种状态的线程不会被分配CPU执行时间。等待状态又分为无限期等待和有限期等待,处于无限期等待的线程需要被其他线程显示地唤醒,没有设置Timeout参数的Object.wait()、没有设置Timeout参数的Thread.join()方法都会使线程进入无限期等待状态;有限期等待状态无须等待被其他线程显示地唤醒,在一定时间之后它们会由系统自动唤醒,Thread.sleep()、设置了Timeout参数的Object.wait()、设置了Timeout参数的Thread.join()方法都会使线程进入有限期等待状态。

    (4)阻塞(Blocked):线程被阻塞了,“阻塞状态”与”等待状态“的区别是:”阻塞状态“在等待着获取到一个排他锁,这个时间将在另外一个线程放弃这个锁的时候发生;而”等待状态“则是在等待一段时间或者唤醒动作的发生。在程序等待进入同步区域的时候,线程将进入这种状态。

    (5)结束(Terminated):已终止线程的线程状态,线程已经结束执行。

    3.线程同步方法

        线程有4中同步方法,分别为wait()、sleep()、notify()和notifyAll()。
    

    wait():使线程处于一种等待状态,释放所持有的对象锁。

    sleep():使一个正在运行的线程处于睡眠状态,是一个静态方法,调用它时要捕获InterruptedException异常,不释放对象锁。

    notify():唤醒一个正在等待状态的线程。注意调用此方法时,并不能确切知道唤醒的是哪一个等待状态的线程,是由JVM来决定唤醒哪个线程,不是由线程优先级决定的。

    notifyAll():唤醒所有等待状态的线程,注意并不是给所有唤醒线程一个对象锁,而是让它们竞争。

    4.创建线程的方式

        在JDK1.5之前,创建线程就只有两种方式,即继承java.lang.Thread类和实现java.lang.Runnable接口;而在JDK1.5以后,增加了两个创建线程的方式,即实现java.util.concurrent.Callable接口和线程池。下面是这4种方式创建线程的代码实现。
    

    4.1继承Thread类

    //继承Thread类来创建线程
    public class ThreadTest {
     
        public static void main(String[] args) {
            //设置线程名字
            Thread.currentThread().setName("main thread");
            MyThread myThread = new MyThread();
            myThread.setName("子线程:");
            //开启线程
            myThread.start();
            for(int i = 0;i<5;i++){
                System.out.println(Thread.currentThread().getName() + i);
            }
        }
    }
     
    class MyThread extends Thread{
        //重写run()方法
        public void run(){
            for(int i = 0;i < 10; i++){
                System.out.println(Thread.currentThread().getName() + i);
            }
        }
    }
    

    4.2实现Runnable接口

    //实现Runnable接口
    public class RunnableTest {
      
        public static void main(String[] args) {
            //设置线程名字
            Thread.currentThread().setName("main thread:");
            Thread thread = new Thread(new MyRunnable());
            thread.setName("子线程:");
            //开启线程
            thread.start();
            for(int i = 0; i <5;i++){
                System.out.println(Thread.currentThread().getName() + i);
            }
        }
    }
      
    class MyRunnable implements Runnable {
      
        @Override
        public void run() {
            for (int i = 0; i < 10; i++) {
                System.out.println(Thread.currentThread().getName() + i);
            }
        }
    }
    

    4.3实现Callable接口

    import java.util.concurrent.Callable;
    import java.util.concurrent.ExecutionException;
    import java.util.concurrent.FutureTask;
    //实现Callable接口
    public class CallableTest {
     
        public static void main(String[] args) {
            //执行Callable 方式,需要FutureTask 实现实现,用于接收运算结果
            FutureTask<Integer> futureTask = new FutureTask<Integer>(new MyCallable());
            new Thread(futureTask).start();
            //接收线程运算后的结果
            try {
                Integer sum = futureTask.get();
                System.out.println(sum);
            } catch (InterruptedException e) {
                e.printStackTrace();
            } catch (ExecutionException e) {
                e.printStackTrace();
            }
        }
    }
     
    class MyCallable implements Callable<Integer> {
     
        @Override
        public Integer call() throws Exception {
            int sum = 0;
            for (int i = 0; i < 100; i++) {
                sum += i;
            }
            return sum;
        }
    }
    

    相较于实现Runnable 接口的实现,方法可以有返回值,并且抛出异常。

    4.4线程池

        线程池提供了一个线程队列,队列中保存着所有等待状态的线程。避免了创建与销毁额外开销,提交了响应速度。
    
    import java.util.concurrent.ExecutorService;
    import java.util.concurrent.Executors;
    //线程池实现
    public class ThreadPoolExecutorTest {
     
        public static void main(String[] args) {
            //创建线程池
            ExecutorService executorService = Executors.newFixedThreadPool(10);
            ThreadPool threadPool = new ThreadPool();
            for(int i =0;i<5;i++){
                //为线程池分配任务
                executorService.submit(threadPool);
            }
            //关闭线程池
            executorService.shutdown();
        }
    }
     
    class ThreadPool implements Runnable {
     
        @Override
        public void run() {
            for(int i = 0 ;i<10;i++){
                System.out.println(Thread.currentThread().getName() + ":" + i);
            }
        }
    
    }
    
    展开全文
  • 操作系统的几个概念

    2019-02-14 17:26:43
    PV原语 执行一次P操作,信号量...在进程的生命周期中,一个进程至少有5基本状态: 初始状态,执行状态,等待状态(阻塞状态),就绪状态和终止状态。 死锁 所谓死锁是指多个并发进程,各自持有资源又都等待...

    PV原语

    执行一次P操作,信号量的值减1,当信号量的值小于等于0时,则阻塞该进程;执行一次V操作,信号量的值加1,若信号量大于0,V原语停止执行,若信号量值小于等于0,应唤醒等待(阻塞)队列中的进程。
    在这里插入图片描述
    在这里插入图片描述

    进程状态

    在进程的生命周期中,一个进程至少有5种基本状态: 初始状态,执行状态,等待状态(阻塞状态),就绪状态和终止状态。

    死锁

    所谓死锁是指多个并发进程,各自持有资源又都等待别的进程释放所拥有的资源,在未改变这种状态之前不能向前推进,这种状态称为死锁。

    产生死锁的原因

    产生死锁的根本原因是系统资源不足,产生死锁的四个必要条件:

    • 互斥条件:并发进程要求和占有的资源只能被一个进程使用
    • 不可剥夺条件:进程已经获得资源,在未使用完成前,不可被剥夺
    • 占有并等待条件:进程申请并等待新资源的过程中,继续占有已分配资源
    • 环路条件:若干进程形成首尾相接的循环链,循环等待上一个进程的资源
      只要系统发生死锁,这些条件必然成立,缺一不可。
    展开全文
  • 线程是进程的执行路径,每个进程必须至少一个线程 内存空间 进程拥有独立内存空间 线程共享进程的内存空间,线程私有程序计数器,虚拟机栈,本地方法栈 切换 进程切换要保存、还原上下文,比较慢 线程切换较快...

    线程与进程的区别(面试常考)

    • 本质
      • 进程是内存中运行的应用程序
      • 线程是进程的执行路径,每个进程必须至少一个线程
    • 内存空间
      • 进程拥有独立内存空间
      • 线程共享进程的内存空间,线程私有程序计数器,虚拟机栈,本地方法栈
    • 切换
      • 进程切换要保存、还原上下文,比较慢
      • 线程切换较快

    线程调度

    有以下几种方法

    • 分时调度
      • 所有线程轮流获得CPU使用权,平均分配每个线程占用CPU的时间(时间片)
    • 抢占式调度
      • 优先级高的线程使用CPU,如果优先级相同就随机,java使用的也是抢占式调度。
      • CPU使用抢占式调度,在多线程间高速切换,看上去就是同一时刻运行多个。能让CPU使用率更高。
        多线程并不能提高程序运行速度,但能提高运行效率

    同步与异步

    • 同步 排队执行 效率低但安全
    • 异步 同时执行 效率高但不安全

    并发与并行(面试常考)

    • 并发:多个时间同一时间段发生,不管是同时发生还是排队执行
    • 并行:确实在同一时刻发生,同时执行。

    多线程实现方法(面试常考)

    如何创建多线程?

    1. 继承Thread类,覆写run()方法,创建Thread对象,通过Thread对象的start()来启动
    2. 实现Runnable接口,覆写run()方法,但还是要创建Thread对象,把Runnable对象传给Thread对象(为线程分配任务)。所以跟1差不多。(比1有好处)

    1.继承Thread覆写run方法,而且需要用Tread对象的start()来启动任务,在线程里调用run方法

    public static void main(String[] args){
            MyThread my = new MyThread();
            my.start();
            for(int i=0;i<5;i++){
                System.out.println("b"+i);
            }
        }
    public class MyThread extends Thread{
        @Override
        public void run(){
            //新的执行路径-线程,触发方式不是直接调用run,而是通过thread对象的start()方法来调用
            for(int i=0;i<5;i++){
                System.out.println("a"+i);
            }
        }
    }
    

    a和b并发执行,每次输出结果都不一样。
    执行流程:

    • main线程开启->main方法执行
      • 开启子线程m(main方法执行时)
        内存区域分配:
    • 每个线程拥有自己的栈空间,共用一份堆内存

    2.实现Runnable接口,也是覆写run

    public class MyRunnable implements Runnable{
        @Override
        public void run(){
            for(int i=0;i<5;i++){
                System.out.println("a"+i);
            }
        }
    }
    
    public static void main(String[] args){
            //1.    创建任务对象Runnable
            MyRunnable r = new MyRunnable();
            //2.    创建线程thread并为其分配任务r
            Thread t = new Thread(r);
            //3.    执行线程
            t.start();
            for(int i=0;i<5;i++){
                System.out.println("b"+i);
            }
        }
    

    与继承Thread相比有优势:

    • 可以多实现,比单继承更灵活
    • 创建任务和线程分配来实现,更适合多个线程同时执行相同任务的情况
    • 任务和线程是分离的,提升健壮性
    • 线程池技术,只接收Runnable类型的任务而不接收Thread类型的线程

    通过匿名内部类开启线程

     new Thread(){
                @Override
                public void run(){
                    for(int i=0;i<5;i++){
                        System.out.println("a"+i);
                    }
                }
            }.start();
    

    守护线程

    守护用户线程的线程。

    • 用户线程:一个进程不包含任何存活用户线程,进程结束
    • 守护线程:当最后一个用户线程结束时,守护线程自动死亡
      设置t1为守护线程,main方法结束就结束了
      t1.setDaemon(true);

    线程名称

    new Thread(new MyRunnable(),"name").start(); 设置线程名称.
    Thread.currentThread().getName());获取当前执行线程的名称

    线程的6种状态(面试常考)

    ENUM Thread.State

    • NEW 尚未启动的线程
    • Runnable 正在执行的线程
    • Blocked 被阻塞 等待监视器锁定
    • Waiting 无限期等待另一个线程执行特定操作 休眠
    • TimedWaiting 等待另一个线程执行最多指定等待时间的操作?
    • Terminated 已退出的线程

    线程休眠

    Thread.sleep(millis:1000);

    线程阻塞

    比如要读用户输入,线程会等着,耗时操作,等待用户输入完成。

    线程中断(打标记,记得释放资源)

    线程是一个独立的执行路径,他的生命周期因其自身决定。否则外部中断可能导致资源没有释放,一直占用。
    线程可以打中断标记,它自己会看,如果有就会触发一个异常InterruptedException,try catch来由程序员来决定是否关闭
    t1.interrupt();给线程t1添加中断标记。
    添加标记之后进入catch块,发现中断标记:

    • wait
    • sleep
    • interrupt
    • interrupted
      可以在异常处理里进行资源释放(交代后事)然后return,就可以让线程自己死亡。

    线程安全问题(面试常考)

    多个线程同时运行时会发生线程不安全的问题。
    解决方法:

    1. 同步代码块 synchronized(锁对象){} 任何对象都可以作为锁存在
    2. 同步方法(1.2.都是隐式锁)
    3. 显式锁Lock

    同步代码块(排队执行)

    while(true){
         synchronized (o) {
              if (count > 0) {
                  System.out.println("卖票");
                  try {
                      Thread.sleep(1000);
    
                  } catch (InterruptedException e) {
                       e.printStackTrace();
                   }
                  count--;
    System.out.println(Thread.currentThread().getName() + "剩余:" + count);
    
                    } else {
                        break;
                    }
                }
                try {
                    Thread.sleep(1000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
    

    同步方法

    让卖票成功返回true,否则返回false。

    public synchronized boolean sale(){
    	if(count>0){
    		//卖票
    		//trycatch sleep1000ms
    		count--;
    	}else break;
    }
    

    显式锁,自己创建锁

    private Lock l = new ReentrantLock();//显式锁
    @Override
    public void run(){
    	while(true){
    		l.lock();
    		if(count>0){
    			//卖票
    			//trycatch让线程sleep1000ms
    		count--;
    		}else break;
    		l.unlock();//对count改变之后释放锁对象
    

    公平锁和非公平锁

    先来先得。

    线程死锁

    互相等待对方释放资源,占用自己所持资源。

    多线程通信

    api:

    • notify()唤醒单个线程 notifyall全唤醒

    生产者与消费者模型

    确保生产者在生产时消费者没有在消费。

    • 生产者生产后,flag=false,先唤醒消费者notifyAll(),再等待wait()
    • 消费者消费后,flag=true,唤醒生产者,等待
    • 用flag控制是否能生产。消费完了才能生产。
    • 生产和消费的方法都需要用synchronized同步
    • wait需要try catch

    创建线程的方法->带返回值的线程Callable

    功能接口,可以用作lambda表达式或方法引用的赋值目标。主线程可以拿到一个结果。
    使用:编写实现Callable接口,实现call方法。

    public static void main(String[] args){
    	Callable<Integer> c = new MyCallable();
    	FutureTask<Integer> task = new FutureTask<>(c);
    	new Thread(task).start();
    	task.get();//要抛出异常
    	//然后执行主线程剩下的代码
    }
    
    class MyCallable implements Callable<T>{
    	@Override
    	public Integer call() throws Exception{
    		Thread.sleep(3000);
    		return 100;
    	}
    }
    
    • task.isDone();//判断子线程是否执行完毕

    线程池(池化技术)

    线程与任务执行流程:

    • 创建线程
    • 创建任务
    • 执行任务
    • 关闭线程
      如果创建和关闭线程的时间比真正创建和执行任务的时间多得多,会浪费大量时间。频繁创建会降低系统效率。线程池能存储大量线程。
      线程池里的空闲线程可以用来执行任务,变为忙状态。

    非定长,缓存线程池

    newCachedThreadPool();

    • 判断是否存在空闲线程
    • 存在则使用
    • 不存在 创建并放入线程池,然后使用
    ExecutorService service = Executors.newCachedThreadPool();
    //指挥线程池执行任务
    service.execute(new Runnable(){
    	@Override...}
    

    定长线程池

    newFixedThreadPool(len);

    • 前同
    • 不存在
      • 线程池已满 等待
      • 不满,创建

    单线程线程池 长度为1的定长线程池

    newSingleThreadExecutor()

    • 空闲则使用,不空闲则等待

    周期性任务定长线程池 在某个时机触发时执行

    • 是否空闲,存在则使用
    • 不存在
      • 未满 创建 放入 使用
      • 已满 等待
    • 周期性任务执行时,定时,自动执行
    ScheduledExecutorService service = Executors.newScheduledThreadPool(size);
    //任务 时长 时长的单位(TimeUnit的常量)
    service.schedule(new Runnable(){
    	...
    	}	
    }, delay:5, period:1, TimeUnit.SECONDS);//5s后执行
    

    Lambda表达式

    1.8版本引入,属于函数式编程思想,让实现接口的写法更简单
    Thread t = new Thread(()->System.out.println(""));
    ()内就是要传入的参数,(参数)->(方法体);

    展开全文
  • 1. 一个进程至少有一个线程 2. 进程是作为资源分配的单位,而线程是调度和执行的单位。 3. 进程关闭了线程一定关闭,线程关闭了进程不一定关闭。 4. 线程有几种状态:创建状态(new)、就绪状态(Runnable)、运行状态...
  • 一个好的调度算法应当考虑以下个方面: 公平:保证每个进程得到合理的CPU时间。 高效:使CPU保持忙碌状态,即总是进程在CPU上运行。 响应时间:使交互用户的响应时间尽可能短。 周转时间:使批处理用户...
  • 文章目录进程和线程以及它们的区别进程间的通信的几种方式线程同步的方式什么是死锁?死锁产生的条件?进程有哪几种状态线程有几种...一个程序至少有一个进程,一个进程至少有一个线程,线程依赖于进程而存在; 进...
  • 正确答案: 通常一个进程至少有不同的状态:运行状态、就绪状态、等待状态。 (1)运行状态(Running):当一个进程正在处理机上运行时,称其处于运行状态。 (2)就绪状态(Ready):当一个进程具备了运行条件,一旦获得处理...
  • 从历史角度看,应用程序如下几种构建方法。  (1) 用一个庞大的程序完成全部工作。程序的各部分可以实现为函数,函数之间通过参数、返回值和全局变量来交换信息。  (2) 使用多个程序,程序之间用某种形式的IPC...
  • 从历史角度看,应用程序如下几种构建方法。  (1) 用一个庞大的程序完成全部工作。程序的各部分可以实现为函数,函数之间通过参数、返回值和全局变量来交换信息。  (2) 使用多个程序,程序之间用某种形式的IPC...
  • 操作系统 前端面试

    2020-04-01 16:23:33
    文章目录进程和线程以及它们的区别进程间的通信的几种方式线程同步的方式什么是死锁?死锁产生的条件?线程有几种状态?分页和分段进程调度策略内存局部性原理 ...一个程序至少有一个进程,一个进程至少有一个...
  • java工程师最新面试题(线程部分)

    千次阅读 2016-03-26 15:34:37
    一般来说,把正在计算机中执行的程序叫做“进程”,所谓的“线程”是指“进程”中某个单一顺序的控制流。 要求读者掌握 1掌握java多线程机制 2.直到进程和线程的区别...a一个程序至少有一个进程,一个进程至少有一个
  • JUC并发编程

    2020-03-03 21:23:39
    一个进程可以包含多个线程,一个进程至少有一个线程!java程序至少有两个线程:GC、Main 并发、并行 并发:多个线程操作同一个资源,交替进行的过程 并行:多个线程可以同时进行!只有在多核CPU下才能够完成! 线程...
  • 一个程序至少有一个进程,一个进程至少有一个线程 死锁的必要条件&怎么处理死锁 死锁产生的必要条件:互斥条件,不可抢占条件,占有且申请条件,循环等待条件 死锁的预防:打破上述四个条件 死锁的避免:安全序列,...
  • JavaSE之JUC基础

    2020-05-31 16:05:54
    一个进程可以包含多个线程,一个进程至少有一个线程! Java程序至少有两个线程: GC、Main 并发、并行 并发:多个线程操作同一个资源,交替执行的过程! 并行:多个线程同时执行!只有在多核CPU下才能完成! 所以...
  • 线程和进程的区别是什么...一个进程至少存在一个线程(主线程)。 在java中两种创建线程的方式:继承Thread类和实现Runnable接口。 线程以下几种状态,创建状态->就绪状态(start)->运行状态(执行ru...
  • 多线程学习总结

    2015-05-21 17:05:19
    进程是指正在执行的程序,每个进程至少有一个线程, 线程是进程中的一个独立控制单元,线程控制着进程执行。 多线程是指多个线程同时进行,可以提高效率。 多线程具有随机性,因为多个线程共同抢夺CPU资源,某一...
  • java 多线程技术基础

    2017-03-12 20:13:04
    对于java程序来说都是jvm上运行的,运行java程序时候jvm就会启动一个进程,该进程中至少有一线程负责java程序执行,该线程运行的代码存在于main方法中,因此也称当前线程为主线程。下图给出了线程的几种状态。 1 ...
  • 系统多线程介绍

    2019-08-12 08:43:04
    线程可以看做是某个进程中的一个控制流,一个进程至少会包括一个线程。并且线程是进程的复制品,但是线程是和进程进行共享内存的,这也就是线程比进程轻量的原因。 线程的状态 线程的状态有以下几种: 就绪状态:这...
  • 深入浅出JUC并发编程

    多人点赞 2020-09-15 21:52:14
    一个进程可以包含多个线程,至少包含一个 线程:是一个单独的资源类 Java默认有几种线程 默认是两个,一个是GC垃圾回收和main方法线程 线程的几种状态 ·新建(NEW) 线程对象一旦创建就会进入到新生状态 ·就绪...
  • Stateful Session Bean 与 Stateless Session Bean ,这两的 Session Bean都可以将系统逻辑放在 method之中执行,不同的是 Stateful Session Bean 可以记录呼叫者的状态,因此通常来说,一个使用者会有一个相对应...
  • Question: 一个Java进程至少有几个线程 Question: 线程有几个状态 Question:Java能创建线程吗 这一天,面试官正好问你开启线程的三方式(Thread、Runable、Callable),冷不防来了一句: Java 能开启线程吗...
  • 一个进程至少包含一个线程(main), 可以包含多个线程.(换言之,线程是进程内的执行单元) 线程与进程相似,它是比进程更小的执行单位.一个进程在执行过程中可以产生多个线程. 同类线程共享的堆和方法区(jdk8之后的元...
  • 入门学习Linux常用必会60命令实例详解doc/txt

    千次下载 热门讨论 2011-06-09 00:08:45
    因为Linux与Windows不同,其后台运行着许多进程,所以强制关机可能会导致进程的数据丢失,使系统处于不稳定的状态,甚至在的系统中会损坏硬件设备(硬盘)。在系统关机前使用 shutdown命令,系统管理员会通知所有...
  • java多线程 [1]

    2011-03-06 23:21:00
    所以又称为轻型进程或进程元,相应的把传统进程称为重型进程,传统进程相当于只有线程的任务,引入了线程的OS中通常一个进程拥有若干个线程,至少一个线程。 <br /> 线程的状态有以下几种:执行状态,...
  • 为了比较着几种重写方案,正则表达式基本上是和前面的IIRF定义中的规则类似的。 页面测试 定义完这些重写规则,我们就可以试着在页面中使用它们了。例如,如果我们写一个测试页面如下: Default.aspx ...
  • 2.5.2 某公司申请到一个C类IP地址,但要连接6个的子公司,最大的一个子公司 26台计算机,每个子公司在一个网段中,则子网掩码应设为? 2.5.3 与10.110.12.29mask 255.255.255.224属于同一网段的主机IP地址是? ...
  • 死锁是两个或两个以上的进程中的每一个,都在等待其中另一个进程释放资源而被封锁,它们都无法向前推进,称这种现象为死锁现象。 产生死锁的原因是共享资源有限,多个进程对共享资源的竞争,而且操作不当。 ...
  • Linux /Unix 共享内存

    2010-08-19 14:00:40
    例子中的0666为权限标识,4/2/1 分别表示读/写/执行3权限,第一个0是UID,第一个6(4+2)表示拥有者的权限,第二个4表示同组权限,第3个0表示他人的权限。 这个函数成功时返回共享内存的ID,失败时返回-1。 关于这个...

空空如也

空空如也

1 2 3 4
收藏数 75
精华内容 30
关键字:

一个进程至少有几种状态