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

最新推荐文章于 2021-06-20 15:20:45 发布

daifei16116010131

最新推荐文章于 2021-06-20 15:20:45 发布

阅读量216

点赞数

本文链接：https://blog.csdn.net/daifei16116010131/article/details/80916864

版权

1 线程的创建与启动

1.1 进程与线程

程序是计算机指令的集合，以文件的形式存储在磁盘上。


进程是一个程序在其自身的地址空间中的一次执行活动。
进程是资源申请、调度和独立运行的单位，因此，它使用系统中的运行资源，而程序不能申请系统资源，不能被系统调度，也不能作为独立运行的单位，因此，它不占系统的运行资源。
线程：进程中的一个单一的连续控制流程。一个进程可以拥有多个线程。
线程又称轻量级进程，它和进程一样拥有独立的执行控制，由操作系统负责调度，区别在于线程没有独立的存储空间，而是和所属进程中的其它线程共享一个存储空间，这使得线程间的通信远较进程简单。

总的来说，线程就可以当做是进程里面的执行的单元,同时它也是这个进程里面的一个能够调度的实体。首先来说进程和线程两个全是基本单元，完全是为了操作系统运行程序而存在的。该类系统为了要实现应用程序的并发性处理，就必须要运用该基本单元。因此它们之间有相似处也有区别。线程和进程的区别可以表现为以下的几个因素：

区别一 : 简单地讲,任何的一个程序都必须有且有一个以上的进程,而相对于一个进程而言也必须要有且有一个以上的线程。相对于进程而言，对线程进行划分的尺度一般要小很多，这就导致了多线程的一些程序能够出现更高的并发性。

区别二 : 在执行进程的时候，一般会具有相互独立的多个内存单元。但是多个线程是可以共享内存的，这样运行效率就很大的程度上被提高了。相对于单个的独立线程而言都会有相应程序的运行入口以及一些程序等出口。线程就不一样了，它不能独立的去执行而必须要依附在相应的应用程序里面。这样的话应用程序就可以执行多个线程并进行相应的控制。

区别三 : 通过了解逻辑角度我们可以得知，多线程这样的意义是相对于在一个应用程序里面的，能够同时的执行。而操作系统不会认为多个线程就是多个独立应用，因此也就不会使其调度以及管理实现资源的分配。

简单地讲线程就是运行活动的集合，它是所有独立功能程序集中于一点的数据集合,进程是独立的单位，它是由系统来进行分配资源以及调度的。

　　换句话说线程可以是进程的实体,也就是CPU调度以及分派的一个很小的体系,可以说它要比进程小很多的基本单位。线程不具备任何的系统资源,它在同样一个进程里面与其他线程共享全部资源。其中一个线程既能够创建也可以撤销其他的线程。同样的，它们之间也能够并发的执行。

1.2 Java中的Thread和Runnable类

区别：Thread是类，而Runnable是接口。
　　抽象类和接口的区别如下：
　　① 在类来继承抽象类时，只需实现部分具体方法和全部抽象方法，而实现接口则要实现里面的全部方法。
　　②在接口中无成员变量，而抽象类中可有成员变量。
　　在Java中引进接口主要是为了解决多继承的问题。
　　实现多线程主要继承Thread 类和实现Runnable接口。

一是写一个类继承自Thread类,然后重写里面的run方法,用start方法启动线程
二是写一个类实现Runnable接口,实现里面的run方法,用new Thread(Runnable target).start()方法来启动

这两种方法都必须实现RUN方法,这样线程起动的时候,线程管理器好去调用你的RUN方法.

你的TestThread没有继承自Thread类,怎么可能会有start方法呢?

在java中可有两种方式实现多线程，一种是继承Thread类，一种是实现Runnable接口；
Thread类是在java.lang包中定义的。一个类只要继承了Thread类同时覆写了本类中的
run()方法就可以实现多线程操作了，但是一个类只能继承一个父类，这是此方法的局限，
下面看例子：
　　package org.thread.demo;
　　class MyThread extends Thread{
　　private String name;
　　public MyThread(String name) {
　　super();
　　this.name = name;
　　}
　　public void run(){
　　for(int i=0;i<10;i++){
　　System.out.println("线程开始："+this.name+",i="+i);
　　}
　　}
　　}
　　package org.thread.demo;
　　public class ThreadDemo01 {
　　public static void main(String[] args) {
　　MyThread mt1=new MyThread("线程a");
　　MyThread mt2=new MyThread("线程b");
      // thread1，thread2，按顺序进行
　　mt1.run();
　　mt2.run();
　　}
　　}
　　但是，此时结果很有规律，先第一个对象执行，然后第二个对象执行，并没有相互运行。在JDK的文档中可以发现，一旦调用start()方法，则会通过JVM找到run()方法。下面启动
　　start()方法启动线程：
　　package org.thread.demo;
　　public class ThreadDemo01 {
　　public static void main(String[] args) {
　　MyThread mt1=new MyThread("线程a");
　　MyThread mt2=new MyThread("线程b");
　　//乱序进行
      mt1.start();
　　mt2.start();
　　}
　　};
      这样程序可以正常完成交互式运行。那么为啥非要使用start()方法启动多线程呢？
　
　在JDK的安装路径下，src.zip是全部的java源程序，通过此代码找到Thread中的start()方法的定义，可以发现此方法中使用了
private native void 
start0();其中native关键字表示可以调用操作系统的底层函数，那么这样的技术成为JNI技术（java Native 
Interface）
　　·Runnable接口
　　在实际开发中一个多线程的操作很少使用Thread类，而是通过Runnable接口完成。
　　public interface Runnable{
　　public void run();
　　}
　　例子：
　　package org.runnable.demo;
　　class MyThread implements Runnable{
　　private String name;
　　public MyThread(String name) {
　　this.name = name;
　　}
　　public void run(){
　　for(int i=0;i<100;i++){
　　System.out.println("线程开始："+this.name+",i="+i);
　　}
　　}
　　};

但是在使用Runnable定义的子类中没有start()方法，只有Thread类中才有。此时观察Thread类，有一个构造方法：public Thread(Runnable target)
　　此构造方法接受Runnable的子类实例，也就是说可以通过Thread类来启动Runnable实现的多
　　线程。（start()可以协调系统的资源）:
　　package org.runnable.demo;
　　import org.runnable.demo.MyThread;
　　public class ThreadDemo01 {
　　public static void main(String[] args) {
　　MyThread mt1=new MyThread("线程a");
　　MyThread mt2=new MyThread("线程b");
　　new Thread(mt1).start();
　　new Thread(mt2).start();
　　}
　　}
　　· 两种实现方式的区别和联系：
　　在程序开发中只要是多线程肯定永远以实现Runnable接口为主，因为实现Runnable接口相比
　　继承Thread类有如下好处：
　　->避免点继承的局限，一个类可以继承多个接口。
　　->适合于资源的共享
　　以卖票程序为例，通过Thread类完成：
　　package org.demo.dff;
　　class MyThread extends Thread{
　　private int ticket=10;
　　public void run(){
　　for(int i=0;i<20;i++){
　　if(this.ticket>0){
　　System.out.println("卖票：ticket"+this.ticket--);
　　}
　　}
　　}
　　};
　　下面通过三个线程对象，同时卖票：
　　package org.demo.dff;
　　public class ThreadTicket {
　　public static void main(String[] args) {
　　MyThread mt1=new MyThread();
　　MyThread mt2=new MyThread();
　　MyThread mt3=new MyThread();
　　mt1.start();//每个线程都各卖了10张，共卖了30张票
　　mt2.start();//但实际只有10张票，每个线程都卖自己的票
　　mt3.start();//没有达到资源共享
　　}
　　}
　　如果用Runnable就可以实现资源共享，下面看例子：
　　package org.demo.runnable;
　　class MyThread implements Runnable{
　　private int ticket=10;
　　public void run(){
　　for(int i=0;i<20;i++){
　　if(this.ticket>0){
　　System.out.println("卖票：ticket"+this.ticket--);
　　}
　　}
　　}
　　}
　　package org.demo.runnable;
　　public class RunnableTicket {
　　public static void main(String[] args) {
　　MyThread mt=new MyThread();
　　new Thread(mt).start();//同一个mt，但是在Thread中就不可以，如果用同一
　　new Thread(mt).start();//个实例化对象mt，就会出现异常
　　new Thread(mt).start();
　　}
　　};
　　虽然现在程序中有三个线程，但是一共卖了10张票，也就是说使用Runnable实现多线程可以达到资源共享目的。
　　Runnable接口和Thread之间的联系：
　　public class Thread extends Object implements Runnable
　　发现Thread类也是Runnable接口的子类。

1.3 三种创建线程的办法

java创建线程的方式有三种
第一种是继承Thread类  实现方法run()  不可以抛异常 无返回值
第二种是实现Runnable接口 实现方法run() 不可以抛异常 无返回值
第三种是实现Callable<T>接口,接口中要覆盖的方法是 public <T> call() 注意:此方法可以抛异常,而前两种不能 而且此方法可以有返回值

第三种如何运行呢  Callable接口在util.concurrent包中,由线程池提交
import java.util.concurrent.*;
ExecutorService e = Executors.newFixedThreadPool(10); 参数表示最多可以运行几个线程
e.submit(); 这个里面参数传 实现Callable接口那个类的对象

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

　2.1 同步的概念和必要性

概念：线程同步就是线程排队。同步就是排队。线程同步的目的就是避免线程"同步"执行。
必要性:不管是多线程还是多进程，涉及到共享相同的内存时，需要确保好同步问题。对线程来说，需要确保每个线程看到一致的数据视图。如果每个线程使用的变量都是其他线程不会读取和修改的，那么就不存在一致性问题，同样的，如果变量是只读的，多个线程同时读取该变量也不会有一致性问题。但是如果其中的某个线程去改变该变量，其他线程也能读取或者修改的时候，我们就需要对这些线程进行同步，确保他们访问变量的存储内容时不会访问到无效的值。当线程修改变量的时候，其他线程在读取这个变量时可能会看到一个不一致的值，在变量修改时间多于一个存储器访问周期的处理器结构中，当存储器读与写这两个周期交叉，不一致就会出现。

2.2 synchronize关键字和同步块

在进行多线程的开发中经常会遇到线程安全问题,那么我们应该如何避免呢.

使用synchronize关键字就可以很好的实现线程安全的程序.

在什么情况下会遇到非线程安全问题呢？比如：

线程A 线程B

1.线程A在数据库中查询存票,发现票C可以卖出
2.线程A接受用户订票请求,准备出票.
3. 这时切换到了线程B执行
4. 线程B在数据库中查询存票,发现票C可以卖出
5. 线程B将票卖了出去
6.切换到线程A执行,线程A卖了一张已经卖出的票

这时就会出现非线程安全问题,原因是两个线程同时访问了一个共同的对象并修改了他.所以我们应该在某个线程正在执行一个不可分割的部分时,其它线程不能同时执行这一部分.

synchronize到底锁住了什么?

对于同步块,synchornized获取的是参数中的对象的锁:
synchornized(obj){
//...............
}
线程执行到这里时,首先要获取obj这个实例的锁,如果没有获取到，线程只能等待.如果多个线程执行到这里,只能有一个线程获取obj的锁,然后执行{}中的语句,所以,obj对象的作用范围不同,控制程序不同.

对于对象和方法,调用synchronize的方法一定是排队运行的.

同步块

2.3 实例

package zheng;

importcom.sun.media.jfxmedia.events.NewFrameEvent;

public class testhread {

static int c=0;

staticObject lock = new Object();

publicstatic void main(String[] args) {

Thread[]thread =new Thread[1000];

for(inti=0;i<1000;i++) {

finalintindex = i;

thread[i]= new Thread(()->{

synchronized(lock){

System.out.println("thread"+index+"enter");

inta = c;//获取c的值

a++;//将值加一

try{//模拟复杂处理过程

Thread.sleep((long)(Math.random()*1000));

}

catch(InterruptedExceptione) {

e.printStackTrace();

}

c=a;//存回去

System.out.println("thread"+index+"leave");

}

});

thread[i].start();//线程开始

}

for(inti=0;i<1000;i++){

try{

thread[i].join();//等待thread i完成

}catch(InterruptedExceptione) {

e.printStackTrace();

}

}//循环后所有的线程都完成了

System.out.println("c="+c);//输出c的结果

}

3 生产者消费者问题

3.1 问题表述

问题描述：一群生产者进程在生产产品，并将这些产品提供给消费者去消费。为了使生产者进程与消费者进程能够并发进行，在两者之间设置一个具有n个缓冲区的缓冲池，生产者进程将产品放入一个缓冲区中；消费者可以从一个缓冲区取走产品去消费。尽管所有的生产者进程和消费者进程是以异方式运行，但它们必须保持同步：当一个缓冲区为空时不允许消费者去取走产品，当一个缓冲区满时也不允许生产者去存入产品。

3.2 实现思路

我们这里利用一个一个数组buffer来表示这个n个缓冲区的缓冲池，用输入指针和输出指针+1来表示在缓冲池中存入或取出一个产品。由于这里的缓冲池是循环缓冲的，故应把in和out表示成：in = ( in +1 ) % n (或把out表示为 out = ( out +1 ) % n )当( in +1) % n= out的时候说明缓冲池满，in = out 则说明缓冲池空。在这里还要引入一个整型的变量counter（初始值0），每当在缓冲区存入或取走一个产品时，counter +1或-1。那么问题的关键就是，把这个counter作为临界资源处理，即令生产者进程和消费者进程互斥的访问它。

3.3实现代码

package org.zheng;

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;
}
}