6種，DES、AES、MD5、RSA、雙鑰加密、非對稱加密。
DES演算法
DES（Data Encryption Standard）是一種經典的對稱演算法。其數據分組長度為64位，使用的密鑰為64位，有效密鑰長度為56位（有8位用於奇偶校驗）。它由IBM公司在70年代開發，經過政府的加密標准篩選後，於1976年11月被美國政府採用，隨後被美國國家標准局和美國國家標准協會(American National Standard Institute， ANSI) 承認。
AES演算法
1997年1月美國國家標准和技術研究所（NIST）宣布徵集新的加密演算法。2000年10月2日，由比利時設計者Joan Daemen和Vincent Rijmen設計的Rijndael演算法以其優秀的性能和抗攻擊能力，最終贏得了勝利，成為新一代的加密標准AES(Advanced Encryption Standard)。
MD5
md5的全稱是message-digest algorithm 5（信息-摘要演算法），在90年代初由mit laboratory for computer science和rsa data security inc的ronald l. rivest開發出來，經md2、md3和md4發展而來。它的作用是讓大容量信息在用數字簽名軟體簽署私人密匙前被"壓縮"成一種保密的格式（就是把一個任意長度的位元組串變換成一定長的大整數）。不管是md2、md4還是md5，它們都需要獲得一個隨機長度的信息並產生一個128位的信息摘要。雖然這些演算法的結構或多或少有些相似，但md2的設計與md4和md5完全不同，那是因為md2是為8位機器做過設計優化的，而md4和md5卻是面向32位的電腦。這三個演算法的描述和c語言源代碼在internet rfcs 1321中有詳細的描述
RSA
RSA演算法是一種非對稱密碼演算法，所謂非對稱，就是指該演算法需要一對密鑰，使用其中一個加密，則需要用另一個才能解密。
RSA的演算法涉及三個參數，n、e1、e2。
其中，n是兩個大質數p、q的積，n的二進製表示時所佔用的位數，就是所謂的密鑰長度。
e1和e2是一對相關的值，e1可以任意取，但要求e1與(p-1)*(q-1)互質；再選擇e2，要求(e2*e1)mod((p-1)*(q-1))=1。
(n及e1),(n及e2)就是密鑰對。
RSA加解密的演算法完全相同,設A為明文，B為密文，則：A=B^e1 mod n；B=A^e2 mod n；
e1和e2可以互換使用，即：
A=B^e2 mod n；B=A^e1 mod n；
雙鑰加密
雙鑰技術就是公共密鑰加密PKE(Public Key Encryption)技術，它使用兩把密鑰，一把公共密鑰(Public Key)和一把專用密鑰(Private Key)，前者用於加密，後者用於解密。這種方法也稱為「非對稱式」加密方法，它解決了傳統加密方法的根本性問題，極大地簡化了密鑰分發的工作量。它與傳統加密方法相結合，還可以進一步增強傳統加密方法的可靠性。更為突出的是，利用公共密鑰加密技術可以實現數字簽名。
什麼是非對稱加密技術
1976年，美國學者Dime和Henman為解決信息公開傳送和密鑰管理問題，提出一種新的密鑰交換協議，允許在不安全的媒體上的通訊雙方交換信息，安全地達成一致的密鑰，這就是「公開密鑰系統」。相對於「對稱加密演算法」這種方法也叫做「非對稱加密演算法」。
⑵ java 銀行演算法
import java.util.*;
class ThreadTest {
static int type = 4, num = 10; //定義資源數目和線程數目
static int[] resource = new int[type]; //系統資源總數
//static int[] Resource = new int[type]; //副本
static Random rand = new Random();
static Bank[] bank = new Bank[num]; //線程組
Bank temp = new Bank();
public void init() {
//初始化組中每個線程，隨機填充系統資源總數
for(int i = 0; i < type; i++)
resource[i] = rand.nextInt(10) + 80;
System.out.print("Resource:");
for(int i = 0; i < type; i++)
System.out.print(" " + resource[i]);
System.out.println("");
for(int i = 0; i < bank.length; i++)
bank[i] = new Bank("#" + i);
}
public ThreadTest4() {
init();
}
class Bank extends Thread {
//銀行家演算法避免死鎖
public int[]
max = new int[type], //總共需求量
need = new int[type], //尚需資源量
allocation = new int[type]; //已分配量
private int[]
request = new int[type], //申請資源量
Resource = new int[type]; //資源副本
private boolean isFinish = false; //線程是否完成
int[][] table = new int[bank.length][type*4]; //二維資源分配表
private void init() {
// 隨機填充總共、尚需、已分配量
synchronized(resource) {
for(int i = 0; i < type; i++) {
max[i] = rand.nextInt(5) + 10;
need[i] = rand.nextInt(10);
allocation[i] = max[i] - need[i];
resource[i] -= allocation[i]; //從系統資源中減去已分配的
}
printer();
for(int i = 0; i < type; i++) {
if(resource[i] < 0) {
//若出現已分配量超出系統資源總數的錯誤則退出
System.out.println("The summation of Threads' allocations is out of range!");
System.exit(1);
}
}
}
}
public Bank(String s) {
setName(s);
init();
start();
}
public Bank() {
//none
}
public void run() {
try {
sleep(rand.nextInt(2000));
}
catch(InterruptedException e) {
throw new RuntimeException(e);
}
while(true) {
//程序沒有完成時一直不斷申請資源
if(askFor() == false) {
try {
sleep(1000);
}
catch(InterruptedException e) {
throw new RuntimeException(e);
}
}
else
tryRequest();
if(noNeed() == true)
break;
}
//休眠一段時間模擬程序運行
try {
sleep(1000);
}
catch(InterruptedException e) {
throw new RuntimeException(e);
}
System.out.println(getName() + " finish!");
synchronized(resource) {
//運行結束釋放佔有資源
for(int i = 0; i < type; i++) {
resource[i] += allocation[i];
need[i] = allocation[i] = max[i] = 0;
}
}
}
private void printer() {
//列印當前資源信息
System.out.print(getName() + " Max:");
for(int i = 0; i < type; i++)
System.out.print(" " + max[i]);
System.out.print(" Allocation:");
for(int i = 0; i < type; i++)
System.out.print(" " + allocation[i]);
System.out.print(" Need:");
for(int i = 0; i < type; i++)
System.out.print(" " + need[i]);
System.out.print(" Available:");
for(int i = 0; i < type; i++)
System.out.print(" " + resource[i]);
System.out.println("");
}
private boolean askFor() {
//隨機產生申請資源量並檢測是否超標
boolean canAsk = false;
for(int i = 0; i < type; i++) {
request[i] = rand.nextInt(20);
//防止申請量超過所需量
if(request[i] > need[i])
request[i] = need[i];
}
for(int i = 0; i < type; i++) //防止隨機申請資源全為0
if(request[i] > 0)
canAsk = true;
synchronized(resource) {
//鎖住可供資源檢查是否超標
for(int i = 0; i < type; i++) {
if(request[i] > resource[i])
//如果申請資源超過可供資源則等待一段時間後重新申請
return false;
}
}
return canAsk;
}
private void tryRequest() {
//創建副本嘗試分配請求
synchronized(resource) {
for(int i = 0; i < type; i++)
//依然要防止請求量超出范圍
if(request[i] > resource[i])
return;
for(int i = 0; i < type; i++) {
//復制資源量並減去需求量到一個副本上
Resource[i] = resource[i];
Resource[i] -= request[i];
}
System.out.print(getName() + " ask for:");
for(int i = 0; i < type; i++)
System.out.print(" " + request[i]);
System.out.println("");
if(checkSafe() == true) {
//如果檢查安全則將副本值賦給資源量並修改佔有量和需求量
for(int i = 0; i < type; i++) {
resource[i] = Resource[i];
allocation[i] += request[i];
need[i] -= request[i];
}
System.out.println(getName() + " request succeed!");
}
else
System.out.println(getName() + " request fail!");
}
}
private boolean checkSafe() {
//銀行家演算法檢查安全性
synchronized(bank) {
//將線程資源信息放入二維資源分配表檢查安全性，0~type可用資源／type~type*2所需資源／type*2~type*3佔有資源／type*3~-1可用+佔用資源
for(int i = 0; i < bank.length; i++) {
for(int j = type; j < type*2; j++) {
table[i][j] = bank[i].need[j%type];
}
for(int j = type*2; j < type*3; j++) {
table[i][j] = bank[i].allocation[j%type];
}
}
//冒泡排序按需求資源從小到大排
for(int i = 0; i < bank.length; i++) {
for(int j = i; j < bank.length-1; j++) {
sort(j, 4);
}
}
//進行此時刻的安全性檢查
for(int i = 0; i < type; i++) {
table[0][i] = Resource[i];
table[0][i+type*3] = table[0][i] + table[0][i+type*2];
if(table[0][i+type*3] < table[1][i+type])
return false;
}
for(int j = 1; j < bank.length-1; j++) {
for(int k = 0; k < type; k++) {
table[j][k] = table[j-1][k+type*3];
table[j][k+type*3] = table[j][k] + table[j][k+type*2];
if(table[j][k+type*3] < table[j+1][k+type])
return false;
}
}
}
return true;
}
private void sort(int j, int k) {
//遞歸冒泡排序
int tempNum;
if(table[j][k] > table[j+1][k]) {
for(int i = type; i < type*2; i++) {
tempNum = table[j][i];
table[j][i] = table[j+1][i];
table[j+1][i] = tempNum;
}
/*temp = bank[j];
bank[j] = bank[j+1];
bank[j+1] = temp;*/
}
else if(table[j][k] == table[j+1][k] && k < type*2) //此資源量相同時遞歸下一個資源量排序並且防止超出范圍
sort(j, k+1);
}
private boolean noNeed() {
//是否還需要資源
boolean finish = true;
for(int i = 0; i < type; i++) {
if(need[i] != 0) {
finish = false;
break;
}
}
return finish;
}
}
public static void main(String[] args) {
ThreadTest t = new ThreadTest();
//後台線程，設定程序運行多長時間後自動結束
new Timeout(30000, "---Stop!!!---");
}
}
希望對你能有所幫助。
⑶ 推薦演算法有哪些
推薦演算法大致可以分為三類：基於內容的推薦演算法、協同過濾推薦演算法和基於知識的推薦演算法。 基於內容的推薦演算法，原理是用戶喜歡和自己關注過的Item在內容上類似的Item，比如你看了哈利波特I，基於內容的推薦演算法發現哈利波特II-VI，與你以前觀看的在內容上面（共有很多關鍵詞）有很大關聯性，就把後者推薦給你，這種方法可以避免Item的冷啟動問題（冷啟動：如果一個Item從沒有被關注過，其他推薦演算法則很少會去推薦，但是基於內容的推薦演算法可以分析Item之間的關系，實現推薦），弊端在於推薦的Item可能會重復，典型的就是新聞推薦，如果你看了一則關於MH370的新聞，很可能推薦的新聞和你瀏覽過的，內容一致；另外一個弊端則是對於一些多媒體的推薦（比如音樂、電影、圖片等)由於很難提內容特徵，則很難進行推薦，一種解決方式則是人工給這些Item打標簽。 協同過濾演算法，原理是用戶喜歡那些具有相似興趣的用戶喜歡過的商品，比如你的朋友喜歡電影哈利波特I，那麼就會推薦給你，這是最簡單的基於用戶的協同過濾演算法（user-based collaboratIve filtering），還有一種是基於Item的協同過濾演算法（item-based collaborative filtering），這兩種方法都是將用戶的所有數據讀入到內存中進行運算的，因此成為Memory-based Collaborative Filtering，另一種則是Model-based collaborative filtering，包括Aspect Model，pLSA，LDA，聚類，SVD，Matrix Factorization等，這種方法訓練過程比較長，但是訓練完成後，推薦過程比較快。 最後一種方法是基於知識的推薦演算法，也有人將這種方法歸為基於內容的推薦，這種方法比較典型的是構建領域本體，或者是建立一定的規則，進行推薦。 混合推薦演算法，則會融合以上方法，以加權或者串聯、並聯等方式盡心融合。 當然，推薦系統還包括很多方法，其實機器學習或者數據挖掘裡面的方法，很多都可以應用在推薦系統中，比如說LR、GBDT、RF（這三種方法在一些電商推薦裡面經常用到），社交網路裡面的圖結構等，都可以說是推薦方法。
⑷ 什麼是銀行家演算法
銀行家演算法是最有代表性的避免死鎖演算法，是Dijkstra提出的銀行家演算法。這是由於該演算法能用於銀行系統現金貸款的發放而得名。
銀行家可以把一定數量的資金供多個用戶周轉使用,為保證資金的安全,銀行家規定:
(1)當一個用戶對資金的最大需求量不超過很行家現有的資金時可接納該用戶.
(2)用戶可以分期貸款,但貸款的總數不能超過最大需求量;
(3)當銀行家現有的資金不能滿足用戶的尚需總數時,對用戶的貸款可推遲支付,但總能使用戶在有限的時間里得到貸款;
(4)當用戶得到所需的全部資金後,一定能在有限的時間里歸還所有資金
銀行家演算法是通過動態地檢測系統中資源分配情況和進程對資源的需求情況來決定如何分配資源的，在能確保系統處於安全狀態時才能把資源分配給申請者，從而避免系統發生死鎖。
要記住的一些變數的名稱
1 Available（可利用資源總數）
某類可利用的資源數目，其初值是系統中所配置的該類全部可用資源數目。
2 Max：某個進程對某類資源的最大需求數
3 Allocation： 某類資源已分配給某進程的資源數。
4 Need：某個進程還需要的各類資源數。
Need= Max-Allocation
系統把進程請求的資源(Request)分配給它以後要修改的變數
Available:=Available-Request;
Allocation:=Allocation+Request;
Need:= Need- Request;
⑸ 哪種加密演算法最安全銀行用的是哪種加密演算法
現在流行的有兩種，一種是加密後不可逆的但是每個值加密後都是唯一的，比如MD5，用在用戶密碼設置。本地在發送密碼前先進行md5加密，然後直接存在用戶伺服器中。下次登錄分別都是在輸入密碼後進行加密再跟伺服器端資料庫中的同樣的加密碼進行匹配。但是現在很多人都在窮舉法一個個的將輸入和輸出進行匹配，現在很多簡單密碼加密後的md5都可以當查字典一樣查到。
還有一種是公鑰和私鑰的加密方法。公鑰和私鑰分別代表兩個值， 數據進行加密依靠這兩個值進行操作，操作完後，私鑰留在本地，公鑰和加密文發給另外一方，另外一方也有私鑰所以可以解密但是中途任何人截獲到了因為沒有私鑰都不能解密。這個一般用在VPN和網銀。 網銀的那個長得像u盤的東西裡面存的就是私鑰和解密程序是不可讀的。不過這個方法一樣有弊端，任何人泄露了其中的東西整個加密系統就會瓦解。
所以沒有絕對安全的加密演算法
⑹ 編程實現銀行家演算法，最好可以告訴我方法，非常感謝。
#include<stdio.h>
#define N 4
#define M 5
main()
{
int maxc[M][N]={3,2,1,4,0,2,5,2,5,1,0,5,1,5,3,0,3,0,3,3};
int availc[M][N]={2,0,1,1,0,1,2,1,4,0,0,3,0,2,1,0,1,0,3,0};
int c[N]={8,5,9,7};
int avail[N]={0};
int i=0,j=0,k[M]={-1,-1,-1,-1,-1},kk=0;
int flag=0;
int flag2=0;
/*The max need table*/
printf("nt The max need table");
printf("n process ");
for(i=0;i<N;i++)
{printf("tR[%d]",i);
}
for(i=0;i<M;i++)
{printf("n p[%d]",i);
for(j=0;j<N;j++)
{printf("t%d",maxc[i][j]);
}
}
/*the rest resource*/
for(j=0;j<N;j++)
{
for(i=0;i<M;i++)
{avail[j]+=availc[i][j];}
avail[j]=c[j]-avail[j];
}
/*The alloc table*/
printf("nnt The allocation table");
printf("n process ");
for(i=0;i<N;i++)
{printf("tR[%d]",i);
}
for(i=0;i<M;i++)
{printf("n p[%d]",i);
for(j=0;j<N;j++)
{printf("t%d",availc[i][j]);
}
}
/*the avail table*/
printf("nn avail");
for(j=0;j<N;j++)
{printf("t%d",avail[j]);}
i=0,j=0;
while(i<M)
{
for(j=0;j<M;j++)
{if(k[j]==i)
{flag=1;i++;break;}
}
if(flag==1)
{flag=0;continue;}
for(j=0;j<N;j++)
{if(avail[j]<maxc[i][j]-availc[i][j])
{flag2=1;i++;j=0;break;}
}
if(flag2==1)
{flag2=0;continue;}
k[kk]=i;
for(j=0;j<N;j++)
{avail[j]+=availc[k[kk]][j];}
/*the avail table*/
printf("n after p[%d]",i);
for(j=0;j<N;j++)
{printf("t%d",avail[j]);}
if(kk==M-1)
{printf("nThis is safe!n");
for(j=0;j<M-1;j++)
{printf("Process[%d]-->",k[j]);}
printf("Process[%d]n",k[M-1]);
break;
}
kk++;
i=0;
}
if(i==M)
printf("nthis is no safe alloc!");
getchar();
}
⑺ 典型現在加密演算法
1.
對稱型加密演算法
也稱私用密鑰演算法.對稱型加密演算法是從傳統的簡單換位代替密碼發展而來的,自1977年美國頒布DES密碼演算法作為美國數據加密標准以來,對稱密鑰密碼體制迅猛發展,得到了世界各國關注和普遍使用.對稱密鑰密碼體制從加密模式上可分為序列密碼和分組密碼兩大類.序列密碼一直是軍事和外交場合使用的主要密碼技術之一,它的主要原理是通過有限狀態機產生性能優良的偽隨機序列,使用該序列加密信息流,得到密文序列.分組密碼的工作方式是將明文分成固定長度的組,如64比特一組,用同一密鑰和演算法對每一組加密,輸出也是固定長度的密文.對稱性的加密演算法包括美國標准56位密鑰的DES,Triple-DES,3DES,變長度密鑰的RC2和RC4,瑞士人發明的128位密鑰的IDEA等.DES(Data Encryption Standard)是由IBM公司開發的最著名的數據加密演算法,它的核心是乘積變換.美國於1997年將其定為非機密數據的正式加密標准.在過去20多年中,DES加密演算法得到了廣泛的研究,比其他任何密鑰方案在硬體和軟體中都得到了更多的應用.DES對64位二進制數據加密,產生64位密文數據,實際密鑰長度為56位(有8位用於奇偶校驗,解密時的過程和加密時相似,但密鑰的順序正好相反),其可能的密鑰有256種,很難被破譯.在銀行業中的電子資金轉賬(EFT)領域中DES的應用獲得成功.現在DES也可由硬體實現,AT&T首先用LSI晶元實現了DES的全部工作模式,該產品稱為數據加密處理機DEP.
+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
2.
RC4演算法
RC4加密演算法
RC4加密演算法是大名鼎鼎的RSA三人組中的頭號人物Ron Rivest在1987年設計的密鑰長度可變的流加密演算法簇。之所以稱其為簇，是由於其核心部分的S-box長度可為任意，但一般為256位元組。該演算法的速度可以達到DES加密的10倍左右。
RC4演算法的原理很簡單，包括初始化演算法和偽隨機子密碼生成演算法兩大部分。假設S-box長度和密鑰長度均為為n。先來看看演算法的初始化部分（用類C偽代碼表示）：
for (i=0; i<n; i++)
s[i]=i;
j=0;
for (i=0; i<n; i++)
{
j=(j+s[i]+k[i])%256;
swap(s[i], s[j]);
}
在初始化的過程中，密鑰的主要功能是將S-box攪亂，i確保S-box的每個元素都得到處理，j保證S-box的攪亂是隨機的。而不同的S-box在經過偽隨機子密碼生成演算法的處理後可以得到不同的子密鑰序列，並且，該序列是隨機的：
i=j=0;
while (明文未結束)
{
++i%=n;
j=(j+s[i])%n;
swap(s[i], s[j]);
sub_k=s((s[i]+s[j])%n);
}
得到的子密碼sub_k用以和明文進行xor運算，得到密文，解密過程也完全相同。
由於RC4演算法加密是採用的xor，所以，一旦子密鑰序列出現了重復，密文就有可能被破解。關於如何破解xor加密，請參看Bruce Schneier的Applied Cryptography一書的1.4節Simple XOR，在此我就不細說了。那麼，RC4演算法生成的子密鑰序列是否會出現重復呢？經過我的測試，存在部分弱密鑰，使得子密鑰序列在不到100萬位元組內就發生了完全的重復，如果是部分重復，則可能在不到10萬位元組內就能發生重復，因此，推薦在使用RC4演算法時，必須對加密密鑰進行測試，判斷其是否為弱密鑰。
但在2001年就有以色列科學家指出RC4加密演算法存在著漏洞，這可能對無線通信網路的安全構成威脅。
以色列魏茨曼研究所和美國思科公司的研究者發現，在使用「有線等效保密規則」（WEP）的無線網路中，在特定情況下，人們可以逆轉RC4演算法的加密過程，獲取密鑰，從而將己加密的信息解密。實現這一過程並不復雜，只需要使用一台個人電腦對加密的數據進行分析，經過幾個小時的時間就可以破譯出信息的全部內容。
專家說，這並不表示所有使用RC4演算法的軟體都容易泄密，但它意味著RC4演算法並不像人們原先認為的那樣安全。這一發現可能促使人們重新設計無線通信網路，並且使用新的加密演算法。
⑻ 銀行家演算法應用在哪些方面
只要是涉及多個獨立個體對某種資源的動態申請和回收就可以應用此演算法。在計算機科學中一般用此演算法檢測進程的推進順序是否是安全隊列，如果不是的話，會因為對資源的爭奪而造成死鎖。