⑴ 积电共享充电宝设备可以回收吗
换位思考，如果你是卖家你同意退吗？好容易逮住买主怎么能轻易放手，不是质量问题卖家是不会退的，合情合理。1.在使用共享充电宝时,要保证手机里的余额足够支付99元的押金。
2.通过微信或支付宝扫码支付押金,再次扫码成功后,共享充电宝便会自动弹出。
3.用共享充电宝自带的安卓、苹果等数据线连接上手机即可。
4.在第一次使用共享充电宝的时候是完全免费,而在之后使用时便会按规定价格收取费用。在使用共享充电宝时，要保证手机里的余额足够支付99元的押金。
2.通过微信或支付宝扫码支付押金，再次扫码成功后，共享充电宝便会自动弹出。
3.用共享充电宝自带的安卓、苹果等数据线连接上手机即可。
4.在第一次使用共享充电宝的时候是完全免费，而在之后使用时便会按规定价格收取费用按租用的时间来收费主要，还有就是对于一些懒得还的人群可以直接以押金抵充电宝的物品价值，当然充电宝企业主要还是以获得资本融资来赚钱，等市场成熟后包装上市，卖给有实力的企业去慢慢运营回本这才是其运作最终的目的！
⑵ 从资源分配的角度可将设备分为独占设备、共享设备和什么网络体系结构是网络功能和什么的集合
独占设备、共享设备,虚拟设备.
网络的体系结构定义:指计算机网络的各层及其协议的集合(architecture).或精确定义为这个计算机网络及其部件所应完成的功能.计算机网络的体系结构综合了OSI和TCP/IP的优点,本身由5层组成:应用层,运输层,网络层,物理层和数据链路层.
⑶ 在考虑到设备的独立性时,应如何分配独享设备
在考虑到设备的独抄立性时，应按如下步骤来分配独占设备：
（1）进程以逻辑设备名提出I/O请求。
（2）根据逻辑设备表相应表项获得I/O请求的逻辑设备对应类型的物理设备在系统设备表
中的指针。
（3）从指针所指位置起顺序检索系统设备表，直到找到一个属于对应I/O请求所用类型、空闲可用且基于设备分配安全性算法验证为安全分配的设备的设备控制表，将对应设备分配给请求进程；如果未找到安全可用的空闲设备，则把请求进程的进程控制块挂到相应类型设备的等待队列上等待唤醒和分配。
（4）系统把设备分配给I/O请求进程后，再到该设备的设备控制表中找出与其相连接的控制器的控制器控制表，根据其状态字段判断该控制器是否忙碌，若忙则把请求进程的进程控制块挂到该控制器的等待队列上；否则将该控制器分配给进程。
（5）系统把控制器分配给I/O请求进程后，再到该控制器的控制器控制表中找出与其相连接的通道的通道控制表，根据其状态字段判断该通道是否忙碌，若忙则把请求进程的进程控制块挂到该通道的等待队列上；否则将该通道分配给进程。
（6）只有在设备、控制器和通道三者都分配成功时，这次的设备分配才算成功，然后便可启动设备进行数据传送。
⑷ 在分页存储管理方式下应怎样实现主存空间的分配和回收
2.1 模拟包括3部分：
1）实现特定的内存分配算法
2）实现内存回收模拟
3）每种内存分配策略对应的碎片数统计
2.2 固定分区存储管理
假设内存容量为120KB，并且分别划分成8,16,32,64KB大小的块各一块。
一个进程所需要的内存为0到100个KB。同时假设一个进程在运行过程中所需内存的大小不变。
模拟五个进程到达请求分配与运行完回收情况,输出主存分配表.
2.3 动态分区分配存储管理
采用连续分配方式之动态分区分配存储管理，使用首次适应算法、下次适应算法、最佳适应算法和最坏适应算法4种算法完成设计(任选两种算法)。
⑸ 从资源分配的角度可将设备分类为_____、共享设备和_____.
独占设备、共享设备，虚拟设备.
⑹ 什么是独占设备，对独占设备如何分配
独占设备，可共享设备只适用于前两种分配技术，即共享设备技术和独占设备技术，但考虑性能要尽量用前者，即共享设备技术来分配；独占设备只适用于后两种分配技术，即独占设备技术和虚拟设备技术，且尽可能采用后者，即虚拟设备技术。
独占设备的分配
1、基本的设备分配程序
---- 当某进程提出I/O请求后，系统的设备分配程序可按下述步骤进行设备分配：
1）分配设备
-- 首先根据I/O请求中的物理设备名，查找系统设备表（SDT），从中找出该设备的DCT（设备分配表），再根据DCT中的设备状态字段，可知
该设备是否正忙。若忙，便将请求I/O进程的PCB挂在设备队列上；否则，便按照一定的算法来计算本次设备分配的安全性。如果不会导致系统
进入不安全状态，便将设备分配给请求进程；否则，仍将其PCB插入设备等待队列。
2）分配控制器
-- 在系统把设备分配给请求I/O的进程后，再到其DCT（指向控制器表的指针）中找出与该设备连接的控制器的COCT（控制器控制表），从COCT
的状态字段中可知该控制器是否忙碌。若忙，便将请求I/O进程的PCB挂在该控制器的等待队列上；否则，便将该控制器分配给进程。
3）分配通道
-- 通过COCT中与控制器连接的通道表指针，找到与该控制器连接的通道的CHCT（通道控制表），再根据CHCT内的状态信息，可知该通道是否
忙碌。若忙，便将请求I/O的进程挂在该通道的等待队列上；否则，将该通道分配给进程。
-- 只有在设备、控制器和通道三者都分配成功时，这次的设备分配才算成功。然后，便可启动该I/O设备进行数据传送。
2、设备分配程序的改进
---- 仔细研究上述基本的设备分配程序后可以发现：
进程是以物理设备名来提出I/O请求的；采用的是单通路的I/O系统结构，容易产生“瓶颈”现象。
为此，应从以下两方面对基本的设备分配程序加以改进，以使独占设备的分配程序具有更强的灵活性，并提高分配的成功率。
1）增加设备的独立性
-- 为了获得设备的独立性，进程应使用逻辑设备名请求I/O。这样，系统首先从SDT中找出第一个该类设备的DCT。
若该设备忙，又查找第二个该类设备的DCT，仅当所有该类设备都忙时，才把进程挂在该类设备的等待队列上；
而只要有一个该类设备可用，系统便进一步计算分配该类设备的安全性。
2）考虑多通路情况
-- 为了防止在I/O系统中出现“瓶颈”现象（通道不足），通常都采用多通路的I/O系统结构。
此时对控制器和通道的分配同样要经过几次反复，即若设备（控制器）所连接的第一个控制器（通道）忙时，应查看其所连接的第二个控制器（通道），
仅当所有的控制器（通道）都忙时，此次的控制器（通道）分配才算失败，才把进程挂在控制器（通道）的等待队列上。
而只要有一个控制器（通道）可用，系统便可将它分配给进程。
⑺ 共享是什么意思如何能和别的机子实现共享怎么做
共享范围很广，现在很多应用也带共享。我想你说的是局域网PC机资源共享，如果是相同系统，又没什么隔离设备，你只要想共享那个盘，那个文件夹或文件或打印机，你只要选中右键单击共享进行设置即可。
⑻ 什么是共享设备
【词组】共享
【拼音】gòng xiǎng
【释义】共享即分享，将一件物品或者信息的使用权或知情权与其他人共同拥有，有时也包括产权。
【示例】不敢独乐,愿与相国共享
⑼ 主存空间的分配和回收，
#include <iostream.h>
#include <stdio.h>
#include <string.h>
struct program
{
char name[30];
long start;
long length;
struct program *next;
};
struct space
{
long start;
long length;
struct space *next;
};
void creat();
void allot();
void back();
void callback(program *r);
void sort(space *L);
void sort(program *S);
void display(space *L);
void display(program *S);
space *L;
program *S;
void creat()
{
L=new space;
space *p=new space;
p->start=0;
p->length=128;
p->next=NULL;
L->next=p;
S=new program;
S->next=NULL;
}
void allot()
{
program *q;
q=new program;
cout<<"请输入进程名和占用空间大小:"<<endl;
cin>>q->name>>q->length;
if(q->length<=0)
{
cout<<"进程空间大小错误."<<endl;
delete q;
return;
}
space *p,*r;
p=L;
r=p;
while(p->next!=NULL&&p->next->length<q->length)
{
r=p;
p=p->next;
}
if(p->next==NULL)
{
cout<<"占用空间过大，分配失败"<<endl;
delete q;
return;
}
else
{
q->start=p->next->start;
q->next=S->next;
S->next=q;
p->next->length-=q->length;
if(p->next->length!=0)
p->next->start+=q->length;
else
{
if(p->next->next!=NULL)
p->next=p->next->next;
else
{
r->next=NULL;
delete p->next;
}
}
}
display(L);
display(S);
}
void back()
{
char name[30];
cout<<"输入要回收的进程名：";
cin>>name;
program *p;
p=S;
while(p->next!=NULL)
{
if(strcmp(p->next->name, name)==0)
{
callback(p);
return;
}
p=p->next;
}
if(p->next==NULL)
cout<<"此进程不存在,内存回收失败"<<endl;
}
void callback(program *t)
{
program *r;
r=t->next;
space *p,*q;
long n;
n=r->length;
if(L->next==NULL)
{
space *w=new space;
w->start=0;
w->length=n;
w->next=NULL;
L->next=w;
t->next=r->next;
delete r;
cout<<"此进程内存回收完毕."<<endl;
display(L);
display(S);
return;
}
p=L->next;
while(p!=NULL&&p->start<r->start)
{
q=p;
p=p->next;
}
if((q->start+q->length==r->start)&&(r->start+n==p->start)) //上下均空
{
q->next=p->next;
q->length=q->length+p->length+n;
t->next=r->next;
delete r;
}
else if(r->start+n==p->start) //下邻空
{
p->start-=n;
p->length+=n;
t->next=r->next;
delete r;
}
else if(q->start+q->length==r->start)
{
q->length+=n;
t->next=r->next;
delete r;
}
else
{
space *sp=new space;
sp->start=r->start;
sp->length=n;
sp->next=L->next;
L->next=sp;
t->next=r->next;
delete r;
}
cout<<"此进程内存回收完毕."<<endl;
display(L);
display(S);
}
void display(space *L)
{
sort(L);
space *p=L->next;
cout<<endl<<"空闲区情况："<<endl;
if(p==NULL)
{ cout<<"无空闲区了."<<endl; return;}
while(p!=NULL)
{
cout<<"起始地址:"<<p->start<<" 长度:"<<p->length<<endl;
p=p->next;
}
}
void display(program *S)
{
sort(S);
program *p=S->next;
cout<<endl<<"进程内存分配情况："<<endl;
if(p==NULL)
{ cout<<"内存中无进程."<<endl; return;}
while(p!=NULL)
{
cout<<"进程名:"<<p->name<<" 起始地址:"<<p->start<<" 长度:"<<p->length<<endl;
p=p->next;
}
cout<<endl;
}
void sort(space *L) //链表排序
{
space *p=L->next, *q, *r;
if(p!=NULL)
{
r=p->next;
p->next=NULL;
p=r;
while(p!=NULL)
{
r=p->next;
q=L;
while(q->next!=NULL&&q->next->start<p->start)
q=q->next;
p->next=q->next;
q->next=p;
p=r;
}
}
}
void sort(program *S) //链表排序
{
program *p=S->next, *q, *r;
if(p!=NULL)
{
r=p->next;
p->next=NULL;
p=r;
while(p!=NULL)
{
r=p->next;
q=S;
while(q->next!=NULL&&q->next->start<p->start)
q=q->next;
p->next=q->next;
q->next=p;
p=r;
}
}
}
void main()
{
creat();
int a;
cout<<" 内存分配与回收模拟"<<endl;
cout<<"1:分配内存"<<endl;
cout<<"2:回收内存"<<endl;
cout<<"0:退出"<<endl;
while(1)
{
cout<<endl<<"请按键选择：";
cin>>a;
if(a>2||a<0)
{
cout<<endl<<"输入错误，请重新输入：";
continue;
}
switch(a)
{
case 1: allot(); break;
case 2: back(); break;
case 0: goto end;
}
}
end:
getchar();
}
#include "iostream.h"
#include "iomanip.h"
#define ERR_NOFREEAREA 1
#define ERR_NOADEQUACYAREA 2
#define ERR_ALLOCATED 4
#define ERR_NOJOBS 1
#define ERR_NOSUCHJOB 2
#define ERR_RECLAIMED 4
typedef struct tagUsedNode
{
long address;
long length;
int flag; //作业名
struct tagUsedNode *next;
} USED_AREA , *USED_TABLE;
typedef struct tagFreeNode
{
long address;
long length;
struct tagFreeNode *next;
} FREE_AREA , *FREE_TABLE;
//空闲区、作业区链表
USED_TABLE usedTable = NULL;
FREE_TABLE freeTable = NULL;
//给作业分配空间
//jobname: 作业名
//jobsize: 作业所需空间大小
int Allocate( int jobname , long jobsize )
{
//如果没有空闲区
if( freeTable == NULL )
return ERR_NOFREEAREA;
FREE_TABLE p = freeTable;
FREE_TABLE q = p;
//找首次适应空闲区
while( p != NULL && p->length < jobsize )
{
q = p;
p = p->next;
}
//如果找不到有足够空间的分区
if( p == NULL )
return ERR_NOADEQUACYAREA;
USED_TABLE x = new USED_AREA;
x->address = p->address;
x->length = jobsize;
x->flag = jobname;
x->next = NULL;
//如果该分区大于作业需求，空间大小减去作业大小
if( p->length > jobsize )
{
p->length -= jobsize;
p->address += jobsize;
}
//如果该分区等于作业大小，删除该分区
else
{
if( p == freeTable )
freeTable = NULL;
else
q->next = p->next;
delete p;
}
//作业加入“作业表”中
USED_TABLE r = usedTable;
USED_TABLE t = r;
while( r != NULL && r->address < x->address )
{
t = r;
r = r->next;
}
if( usedTable == NULL )
usedTable = x;
else
{
x->next = r;
t->next = x;
}
return ERR_ALLOCATED;
}
//回收作业空间
//jobname: 作业名
int Reclaim( int jobname )
{
if( usedTable == NULL )
return ERR_NOJOBS;
USED_TABLE p = usedTable;
USED_TABLE q = p;
while( p != NULL && p->flag != jobname )
{
q = p;
p = p->next;
}
//如果没有该作业
if( p == NULL )
return ERR_NOSUCHJOB;
//回收后的空间加入到空闲区
FREE_TABLE r = freeTable;
FREE_TABLE t = r;
FREE_TABLE x;
while( r != NULL && r->address < p->address )
{
t = r;
r = r->next;
}
x = new FREE_AREA;
x->address = p->address;
x->length = p->length;
x->next = NULL;
if( r == freeTable )
{
x->next = r;
freeTable = x;
t = freeTable;
}
else
{
x->next = r;
t->next = x;
}
//合并分区
while( t->next != NULL && t->address + t->length == t->next->address )
{
t->length += t->next->length;
r = t->next;
t->next = t->next->next;
delete r;
}
//删除该作业
if( p == usedTable )
{
usedTable = usedTable->next;
}
else
q->next = p->next;
delete p;
return ERR_RECLAIMED;
}
int Init()
{
freeTable = new FREE_AREA;
freeTable->address = 0;
freeTable->length = 1024;
freeTable->next = NULL;
return 1;
}
void jobrequest()
{
int jobname;
int jobsize;
cout<<"...................."<<endl;
cout<<"作业名: ";
cin >> jobname;
cout<<"作业长度: ";
cin >> jobsize;
if( Allocate( jobname , jobsize ) == ERR_ALLOCATED )
cout<<"该作业已成功获得所需空间"<<endl;
else
cout<<"该作业没有获得所需空间"<<endl;
cout<<"...................."<<endl;
}
void jobreclaim()
{
int jobname;
cout<<"...................."<<endl;
cout<<"作业名: ";
cin >>jobname;
int result = Reclaim( jobname );
if( result == ERR_RECLAIMED )
cout<<"该作业已成功回收"<<endl;
else if( result == ERR_NOSUCHJOB || result == ERR_NOJOBS )
cout<<"系统没有作业或该作业不存在"<<endl;
cout<<"...................."<<endl;
}
void freeTablePrint()
{
cout<<"........................................"<<endl;
cout<<setw(10)<<"address"<<setw(10)<<"length"<<setw(10)<<"state"<<endl<<endl;
FREE_TABLE p = freeTable;
USED_TABLE q = usedTable;
int x , y;
while( p || q )
{
if( p )
x = p->address;
else
x = 0x7fffffff;
if( q )
y = q->address;
else
y = 0x7fffffff;
if( x < y )
{
cout<<setw(10)<<p->address<<setw(10)<<p->length<<setw(10)<<"空闲"<<endl;
p = p->next;
}
if( x > y )
{
cout<<setw(10)<<q->address<<setw(10)<<q->length<<setw(10)<<"已分配"<<setw(10)<<"ID="<<q->flag<<endl;
q = q->next;
}
}
cout<<"........................................"<<endl;
}
void main()
{
Init();
int choose;
bool exitFlag = false;
while( !exitFlag )
{
cout<<"选择功能项 ( 0 - 退出 1 - 分配主存 2 - 回收主存 3 - 显示主存 )"<<endl;
cout<<"?>";
cin>>choose;
switch( choose )
{
case 0:
exitFlag = true;
break;
case 1:
jobrequest();
break;
case 2:
jobreclaim();
break;
case 3:
freeTablePrint();
break;
}
}
}
⑽ 页，分段，段页式这些方法都是怎样对内存进行分配和回收的
Linux 采用 Buddy 算法有效分配和释放物理页块。 linux系统内存管理的特点linux的进程结束后，它占用的资源全部释放，但是内存仅仅是设置了标志，标志了这部分内存已经不再使用，可以被重新分配的。当进程需要内存时，linux系统首先从空闲内存中...