⑴ 積電共享充電寶設備可以回收嗎
換位思考，如果你是賣家你同意退嗎？好容易逮住買主怎麼能輕易放手，不是質量問題賣家是不會退的，合情合理。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系統首先從空閑內存中...