操作系统编程实践课程总结

1 线程的创建与启动

1.1 进程与线程

线程：有时被称为轻量级进程 (Lightweight Process ， LWP ），是程序执行流的最小单元。一个标准的线程由线程 ID ，当前指令 指针 (PC ）， 寄存器 集合和 堆栈 组成。另外，线程是进程中的一个实体，是被系统独立调度和分派的基本单位，线程自己不拥有系统资源，只拥有一点儿在运行中必不可少的资源，但它可与同属一个进程的其它线程共享进程所拥有的全部资源。一个线程可以创建和撤消另一个线程，同一进程中的多个线程之间可以并发执行。由于线程之间的相互制约，致使线程在运行中呈现出间断性。线程也有 就绪 、 阻塞 和 运行 三种基本状态。就绪状态是指线程具备运行的所有条件，逻辑上可以运行，在等待处理机；运行状态是指线程占有处理机正在运行；阻塞状态是指线程在等待一个事件（如某个信号量），逻辑上不可执行。每一个程序都至少有一个线程，若程序只有一个线程，那就是程序本身。

进程：是计算机中的程序关于某数据集合上的一次运行活动，是系统进行资源分配和调度的基本单位，是操作系统结构的基础。在早期面向进程设计的计算机结构中，进程是程序的基本执行实体；在当代面向线程设计的计算机结构中，进程是线程的容器。程序是指令、数据及其组织形式的描述，进程是程序的实体。

1.2 Java中的Thread和Runnable类

一个Thread类的对象对应一个线程

Threadt = new Thread(obj)

Obj:Runnable的对象

1.3 三种创建线程的办法

1）继承Thread类创建线程

2）实现Runnable接口创建线程

3）使用Callable和Future创建线程

2 线程简单同步（同步块）

2.1 同步的概念和必要性

所谓同步，就是在发出一个功能调用时，在没有得到结果之前，该调用就不返回，同时其它线程也不能调用这个方法。因为当我们有多个线程要同时访问一个变量或对象时，如果这些线程中既有读又有写操作时，就会导致变量值或对象的状态出现混乱，从而导致程序异常

2.2 synchronize关键字和同步块

synchronized 关键字，代表这个方法加锁,相当于不管哪一个线程A每次运行到这个方法时,都要检查有没有其它正在用这个方法的线程B（或者C D等）,有的话要等正在使用这个方法的线程B（或者C D）运行完这个方法后再运行此线程A,没有的话,直接运行它包括两种用法：synchronized 方法和 synchronized 块。

2.3 实例

package luobing;

import com.sun.media.jfxmedia.events.NewFrameEvent;

public class testhread {

static int c=0;
static Object lock = new Object();
public static void main(String[] args) {
Thread[] thread = new Thread[1000];
for(int i=0;i<1000;i++) {
final int index = i;
thread[i] = new Thread(()->{
synchronized(lock) {
System.out.println("thread"+index+"enter");

int a = c;//获取c的值
a++;//将值加一
try {//模拟复杂处理过程
Thread.sleep((long)(Math.random()*1000));
}
catch(InterruptedException e) {
e.printStackTrace();
}
c=a;//存回去
System.out.println("thread"+index+"leave");
}
});
thread[i].start();//线程开始
}
for(int i=0;i<1000;i++) {
try {
thread[i].join();//等待thread i完成
}catch(InterruptedException e) {
e.printStackTrace();
}
}//循环后所有的线程都完成了
System.out.println("c="+c);//输出c的结果

}

}

3 生产者消费者问题

3.1 问题表述

3.1 问题表述

生产者消费者问题，也称有限缓冲问题，是一个多线程同步问题的经典案例。该问题描述了两个共享固定大小缓冲区的线程——即所谓的“生产者”和“消费者”——在实际运行时会发生的问题。生产者的主要作用是生成一定量的数据放到缓冲区中，然后重复此过程。与此同时，消费者也在缓冲区消耗这些数据。该问题的关键就是要保证生产者不会在缓冲区满时加入数据，消费者也不会在缓冲区中空时消耗数据。

3.2 实现思路

生产者：负责生产消息，在缓冲区满后休眠； 
消费者：负责消费消息，在缓冲区空后休眠

3.3 Java实现该问题的代码

package org.luo; 

import java.util.LinkedList;

importjava.util.concurrent.locks.Condition; 

importjava.util.concurrent.locks.Lock; 

import java.util.concurrent.locks.ReentrantLock; 

public class Queue { //队列

//(1)建立一个锁，俩信号量 

private Lock lock =new ReentrantLock(); //锁 

private Condition fullC; //信号量 

private Condition emptyC; //信号量 

private int size; 

public Queue(int size) { 

this.size = size; 

//（2）为信号量赋初值 

fullC = lock.newCondition(); 

emptyC = lock.newCondition(); 





} 

LinkedList<Integer> list = new LinkedList<Integer>();

/** 

 * 入队 

 * @return 

 */ 

public boolean EnQueue(int data) { 

lock.lock(); //上锁 

while(list.size()>=size) { 

try { 

fullC.await();

} catch (InterruptedException e) { 

lock.unlock(); 

return false; 

}

} 

list.addLast(data);

emptyC.signalAll(); lock.unlock();

return true;

} 

/** 

 * 出队 

 * @return

 */ 

public int DeQueue() {

lock.lock(); //先上锁 

while(list.size() == 0) { //如果队列为空，则等待生产者 唤醒我 

try { 

emptyC.await(); 

} catch (InterruptedException e) { 

lock.unlock(); 

return -1; //失败返回 

} 

} 

int r = list.removeFirst(); //获取队列头部 

fullC.signalAll(); //唤醒所有的生产者 

lock.unlock(); //解锁 

return r; 

} 

public boolean isFull() {

return list.size()>=size; 

} 

public boolean isEmpty() {

return list.size()==0; 

} 

}

3.4 测试

3.4.1 当生产能力超出消费能力时的表现

当生产能力超出消费能力时，当生产者线程生产物品时,如果没有空缓冲区可用,那么生产者线程必须等待消费者线程。

3.4.2 当生产能力弱于消费能力时的表现

当生产能力弱于消费能力时，当消费者线程消费物品时,如果没有满的缓冲区,那么消费者线程将被阻塞,直到新的物品被生产出来。

4 总结

通过这一天的实践学习，我对操作系统这门课有了更加深刻的理解，学到了很多平时课堂上学习不到的知识。让我更加知道了计算机真的很实用很伟大，通过计算机通过网络可以学习到很多。还有就是打字速度真的要多练习，太影响效率了