Sau một thời gian ẩn mình tu luyện thì mình đã trở lại đây để chuyển hướng các bạn về trang blog mới của mình.
Link: https://anhlamweb.com/
Fanpage Facebook: https://www.facebook.com/anhlamweb.oi
Chúc các bạn tìm được bài viết mà các bạn đang cần nhé!
Arrow function là cách viết hàm một cách ngắn gọn hơn so với cách viết hàm trong Javascript như trước, được đưa vào từ phiên bản ES6.
Thông thường để viết hàm trong Javascript theo cách cũ thì có 2 cách viết như sau:
//Cách 1
function functionName(value1, value2){
}
//Cách 2
var functionName=function(value1, value2){
}
Bây giờ chúng ta sẽ chuyển nó về Arrow Function như sau:
var functionName = (value1, value2)=>{
}
Như ở trên chúng ta sẽ bỏ đi khai báo hàm function nhưng thêm vào dấu => vào cuối dấu đóng ngoặc “)”.
Ví dụ 1:
Arrow Function không có tham số truyên vào được viết như sau:
let helloArrowFunction = () => {
console.log("Xin chào bạn");
}
helloArrowFunction();
Kết quả:
Ví dụ 2:
Arrow Function hàm có tham số truyên vào được viết như sau:
let helloArrowFunction = (valueName) => {
console.log("Xin chào "+valueName);
}
helloArrowFunction("Arrow Function");
Khi hàm có tham số thì các tham số được để vào trong dấu () và cách nhau bở dấu “,” như thông thường.
Kết quả:
Ở trong dấu {} có 1 dòng lệnh duy nhất thì ta có thể viết lại hàm trên như sau:
let helloArrowFunction = (valueName) => console.log("Xin chào "+valueName);
helloArrowFunction("Arrow Function");
Kết quả vẫn giống như ban đầu.
Ví dụ 3:
Cách viết thường.
let myFunction =function(valueName){
return valueName * 2;
}
console.log(myFunction(5));
Cách viết Arrow Function.
let myFunction =(valueName)=>{
return valueName * 2;
}
console.log(myFunction(5));
Ở đây có một dòng lệnh là trả về kết quả duy nhất nên ta có thể bỏ đi dấu ngoặc {}.
//Cách viết sai
let myFunction =(valueName)=> return valueName * 2; console.log(myFunction(5));
Khi viết Arrow Function với một dòng lệnh return duy nhất giông ví dụ này thì chúng ta không được phép viết return vào nữa bởi vì dấu => thì trình duyệt đã hiểu nó là lệnh return rồi, nếu viết thêm sẽ có thông báo lỗi.
//Cách viết đúng
let myFunction =(valueName)=> return valueName * 2; console.log(myFunction(5));
Kết quả:
Để đọc hiểu code của những người khác thì chúng ta nên học những ví dụ đơn giản như thế này trước để hiểu cách thức hoạt động của nó và chúng ta có thể sử dụng nó cho code của mình vì nó cải tiến và đơn giản hơn rất nhiều so với ES5.
ES được viết tắt của ECMAScript, là chuẩn của ngôn ngữ Javascript được các công ty lớn chung tay vào việc xây dựng và thống nhất cách hoạt động của ngôn ngữ Javascript trên các trình duyệt web, để đảm bảo cho tất cả các website trên các trình duyệt khác nhau có thể hoạt động tốt.
ES5 được công bố vào năm 2011, ES6 được công bố vào năm 2015 với tên ES2015, mỗi năm sẽ có một phiên bản ECMAScript mới với nhiều tính năng mới, hiện tại đã có bản ES2017 – ES8 với các tính năng bổ sung như asyn, await để xử lý việc bất đồng bộ trong ngôn ngữ javascript.
Từ phiên bản ES6 trở đi chúng ta đã có được rất nhiều tính năng cải tiến cho ngôn ngữ Javascript hơn nào cùng mình tìm hiểu các tính năng đó nhé.
Ở ES5 chỉ có 1 cách để khai báo biến đó là từ khóa var, var có thể là số, có thể là chuổi …v.v… nó không có một nguyên tắc nào cả vì thế từ phiên bản ES6 đã có thêm từ khóa let và const, ồ bây giờ chúng ta đã có tới 3 cách để khai báo kiểu dữ liệu rồi đấy, vậy 2 từ khóa mới này nó có công dụng là gì nhỉ? Nào cùng đi vào ví dụ để cùng nhau hiểu rõ hơn nào.
Tạo một file index.html trong đó có đoạn script này:
Ví dụ 1:
for(var i=0; i<5; i++){
console.log(i);
}
console.log("Biến i ngoài vòng lặp: "+i);
Kết quả sau khi chạy:
Ta thấy rằng biến i=5 vẫn tồn tại sau khi đã ra khỏi vòng lặp và nó vẫn chưa được giải phóng khỏi vùng nhớ.
Ví dụ 2:
Ở ví dụ này ta cho các câu lệnh ở trên vào một hàm rồi chạy thử xem sao.
function myFunction() {
for (var i = 0; i < 5; i++) {
console.log(i);
}
console.log("Biến i ngoài vòng lặp: " + i);
}
myFunction();
Kết quả sau khi chạy:
Kết quả vẫn vậy nhưng giả sử ta biên đổi lại code như vậy thì sao:
function myFunction() {
for (var i = 0; i < 5; i++) {
console.log(i);
}
}
myFunction();
console.log("Biến i ngoài vòng lặp: " + i);
Kết quả sau khi chạy:
Đã có thông báo lỗi và trình duyệt không hiểu biến i đó, như vậy biến i nếu được khai báo kiểu var và ở trong hàm myFunction thì nó chỉ có hiệu lực trong hàm đó mà thôi, ra khỏi hàm thì nó sẽ không tồn tại nữa.
Còn nếu biến i không khai báo trong hàm thì nó sẽ hiểu là biến toàn cục luôn.
function myFunction() {
for (i = 0; i < 5; i++) {
console.log(i);
}
}
myFunction();
console.log("Biến i ngoài vòng lặp: " + i);
Kết quả sau khi chạy:
Để tránh trường hợp như vậy chúng ta có thể sử dụng strict mode bằng cách đưa thêm vào từ khóa ‘use strict’ vào đầu file javascript.
Thêm ‘use strict’ vào đầu đoạn script như đoạn code bên dưới để bật chế độ strict mode.
Ví dụ 3:
'use strict'
function myFunction() {
for (i = 0; i < 5; i++) {
console.log(i);
}
}
myFunction();
console.log("Biến i ngoài vòng lặp: " + i);
Code sau khi chỉnh sửa:
'use strict'
function myFunction() {
for (var i = 0; i < 5; i++) {
console.log(i);
}
}
myFunction();
‘use strict’ được đưa vào từ phiên bản ES6 của Javascript khi có ‘use strict’ thì code javascript của chúng ta sẽ có tính chặt chẽ hơn.
Ví dụ 4:
'use strict'
for(let i=0; i<5; i++){
console.log(i);
}
console.log("Biến i ngoài vòng lặp: "+i);
Kết quả sau khi chạy:
Trình duyệt đã không hiểu biến i khi nó ra khỏi dấu cặp {} rồi, vậy biến i khi được khai báo bằng từ khóa let thì trình duyệt chỉ hiểu nó khi nằm trong dấu cặp {} bao quanh nó.
Ví dụ 5:
'use strict'
var i=999;
if(true){
var i=555;
}
console.log(i);
Kết quả:
Còn khi chúng ta sử dụng let thì sao.
'use strict'
var i=999;
if(true){
let i=555;
}
console.log(i);
Kết quả:
Ví dụ 6:
'use strict'
var i=999;
{
{
let i=555;
console.log(i);
}
console.log(i);
}
console.log(i);
Kết quả:
Ví dụ 7:
'use strict' const i=999; i=10; console.log(i);
Kết quả:
Chúng ta nên sử dụng từ khóa let thay cho từ khóa var và cũng nên sử dụng ‘use strict’ ở đầu file javascript để code trở nên chặt chẽ hơn.
I. Tải Virtual Breadboard Và Cách Cài Đặt.
Link tải: Virtual breadboard 4.46 + Crack.
Sau khi thực hiện việc tải Virtual breadboard với đường link mình đã cung cấp ở trên giải nén và được thư mục có chứa các file như hình bên dưới
Các bước làm như sau:
II. Virtual Breadboard và chương trình led nhấp nháy với Arduino sẵn có.
Trong Virtual Breadboard có các ví dụ đơn giản với Arduino có sẵn code luôn. Các bạn có thể test thử xem chương trình có chạy được hay không nếu chạy được thì ở bước trước chúng ta đã crack chương trình thành công rồi đấy.
Vào File -> New -> Arduino Distribution -> Digital -> BlinkWithoutDelay.VSM sau đó click Open để mở chương trình được thiết kế và viết sẵn code.
Đây là phần code và thiết kế ta click vào nút Run chương trình để thực hiện.
Sau khi Run chương trình thì đèn đã nhấp nháy rồi. Như vậy chúng ta đã cài đặt thành công Virtual Breadboard 4.46 rồi, nào cùng trải nghiệm.
Mình có nghe nói đến 1000 bài tập về kỹ thuật lập trình của thầy Nguyễn Tấn Trần Minh Khang, để ôn lại kiến thức cũ hằng ngày mình sẽ giải 5 câu. Dù biết đã có code sẵn trên mạng hết cả rồi nhưng mình vẫn thích tự giải lại để hiểu rõ hơn.
Đây là file PDF gồm 1000 bài tập mình tìm thấy trên trang thảo luận daynhauhoc.com.
Link PDF: https://drive.google.com/file/d/0BxMt6htzBQpIMHVVSDRrQ3BWRlE/view
I. Hành trình giải từ câu 1 đến câu 5.
Nhìn thì có vẻ hơi phức tạp nhưng thực chất thì những câu dạng này đều tuân theo một quy luật nhất định.
Câu 1:
//Tính S(n)=1+2+3+...+n.
int S1(int n)
{
int s=0;
for (int i = 1; i <= n; i++)
{
s += i;
}
return s;
}
Câu 2:
//Tính S(n)=1^2+2^2+3^2+...+n^2.
int Power(int num,int k)
{
int m = 1;
for (int i = 1; i <= k; i++)
{
m *= num;
}
return m;
}
int S2(int n)
{
int s = 0;
for (int i = 1; i <= n; i++)
{
s += Power(i,2);
}
return s;
}
Câu 3:
//Tính S(n)=1+1/2+1/3+...+1/n.
float S3(int n)
{
float s = 1;
for (int i = 2; i <= n; i++)
{
s += (float)1/i;
}
return s;
}
Câu 4:
//Tính S(n)=1/2+1/4+...+1/2*n.
float S4(int n)
{
float s = 0;
for(int i=1;i<=n;i++)
{
s+=(float)1/(2*i);
}
return s;
}
Câu 5:
//Tính 1+1/3+1/5+...+1/(2n+1).
float S5(int n)
{
float s = 1;
for (int i = 1;i <= n ; i++)
{
s += (float)1 / (2 * i + 1);
}
return s;
}
II. Hành trình giải từ câu 6 đến câu 10.
Câu 6:
//Tính 1/1*2 + 1/2*3 +...+1/n*(n+1).
float S6(int n)
{
float s=0;
for(int i=1; i<=n; i++)
{
s+=(float)1 / (i*(i+1));
}
return s;
}
Câu 7:
//Tính 1/2+2/3+3/4+...+n/(n+1).
float S7(int n)
{
float s=0;
for(int i=1; i<=n; i++)
{
s+=(float)i/(i+1);
}
return s;
}
Câu 8:
//Tính 1/2+3/4+5/6+...+(2n+1)/(2n+2).
float S8(int n)
{
float s=0;
for(int i=0; i<=n; i++)
{
s+=(float)(2*i+1)/(2*i+2);
}
return s;
}
Câu 9:
//Tính 1*2*3*...*n.
int S9(int n)
{
int m=1;
for(int i=2; i<=n; i++)
{
m*=i;
}
return m;
}
Câu 10:
//Tính T(x,n)=x^n.
//Giống hàm Power.
int Power(int num,int k)
{
int m = 1;
for (int i = 1; i <= k; i++)
{
m *= num;
}
return m;
}
Lưu ý: Ở những phép toán chia ví dụ 1 / 2 = 0,5 là số nguyên chia cho số nguyên kết quả phải ra số nguyên mà nếu kết quả là số nguyên thì chỉ lấy phần nguyên ở kết quả, 0,5 chỉ lấy phần nguyên thôi thì sẽ là 0, chính vì vậy có thể dẫn đến sai số nghiêm trọng trong quá trình tính toán.
Để khắc phục điều đó ta phải ép kiểu tử số hoặc mẫu số về dạng kiểu số thực float hay double để kết quả của phép chia là kiểu số thực. Ví dụ như (float)1/2 = 0,5 ở đây ta ép kiểu tử số viết rõ ràng hơn ((float)1)/2 = 0,5 như vậy kết quả cuối cùng sẽ không bị sai số.
I. Giải Pháp Chờ Đợi Bận
Giải pháp này chỉ áp dụng khi có 2 tiến trình cùng thực thi 1 lúc, P0 và P1. quy uớc 1 tiến trình là Pi, và Pj là tiến trình còn lại, khi đó j = 1 – i.
cho 2 tiến trình sử dụng 1 biến dùng chung turn = 0 hoặc 1; nếu turn ==0 thì Pi được thực thi trong vùng tranh chấp của nó.
Trong đó
critical section: vùng tranh chấp chứa mã thực thi của tiến trình.
remainder section: phần còn lại thực hiện một số thao tác phụ.
//Tiến trình Pi
do{
while (turn != i);
//critical section
turn = j;
//remainder section
}while(1);
//Tiến trình Pj
do{
while (turn != j);
//critical section
turn = i;
//remainder section
}while(1);
Hạn chế:
Giải thuật không giữ được thông tin trạng thái của mỗi tiến trình.
Thay thế turn bằng boolean flag[2], gán các phần tử trong flag giá trị là false, nếu flag[i] == true → Pi sẵn sàng đi vào vùng tranh chấp.
//Tiến trình Pi
do{
flag[i] = true;
while (flag[j]);
//critical section
flag[i] = false;
//remainder section
}while(1);
//Tiến trình Pj
do{
flag[j] = true;
while (flag[i]);
//critical section
flag[j] = false;
//remainder section
}while(1);
Hạn chế:
Tiến trình P0, P1 sẽ đợi chờ mãi.
Tiến trình P1 được vào vùng tranh chấp.
Tiến trình P0 được vào vùng tranh chấp.
Nếu tiến 1 trong 2 tiến trình P0 hoặc P1 vào vùng sẵn sàng chạy trước thì sẽ được chạy trước, vì sẽ có flag[0] hoặc flag[1] sẽ bằng false.
Nếu cả 2 tiến trinhg P0 và P1 vào vùng sẵn sàng và bật flag[i]=true và flag[j]=true cùng lúc thì P0 và P1 sẽ chờ đợi mãi.
II. Giải Thuật Peterson
Giải thuật Peterson là sự kết hợp từ 2 giải thuật 1 và 2 ở trên.
//Tiến trình Pi
do{
flag[i] = true;
turn=j;
while (flag[j] && turn==j);
//critical section
flag[i] = false;
//remainder section
}while(1);
//Tiến trình Pj
do{
flag[j] = true;
turn=i;
while (flag[i] && turn=i);
//critical section
flag[j] = false;
//remainder section
}while(1);
Pi đi vào vùng tranh chấp nếu và chỉ nếu flag[j] = false hoặc turn = 0.
Không thể có trường hợp 2 tiến trình cùng thực thi 1 lúc, vì giả sử điều này xảy ra, ta có flag[i]==flag[j] == true, nhưng turn sẽ là 1 hoặc 0.
Giả sử turn = i, và turn = j được thực hiện đồng thời, khi đó sẽ chỉ có 1 kết quả cuối cùng, và vì vậy, turn == 0, hoặc turn == 1.
II. Giải Thuật Bakery
Loading…
1. Giải thích quá trình thực thi chương trình của CPU theo Figure 1.4, trang 13, William Stallings, “Operating Systems”, 7th edition, 2012.
– PC viết tắt của Program counter (Bộ đếm chương trình): chứa địa chỉ của dòng lệnh tiếp theo
– IR viết tắt của Instruction register (Thanh ghi lệnh) : chứa lệnh đang được thực thi
– AC viết tắt của Accumulator : là bộ nhớ tạm thời
– 1=0001 là lấy dữ liệu từ bộ nhớ
– 2=0010 lưu thanh ghi AC vào bộ nhớ
– 5=0101 cộng vào thanh ghi AC từ bộ nhớ
Lưu ý giá trị đầu tiên từ bên trái qua là cách thức thực thi ở đây là 1, phần phía sau là địa chỉ mà lệnh đó thực thi.
Bước 1:
Đọc từ thanh ghi PC địa chỉ của lệnh cần lấy hình trên địa chỉ là 300 sau đó đưa dòng lệnh tại địa chỉ 300 là 1940 vào thanh ghi IR
Bước 2:
Đưa địa chỉ lệnh tiếp theo cần thực thi vào thanh ghi PC, thanh ghi PC lúc này chứa địa chỉ 301.
Thực thi lệnh 1940 ở thanh ghi IR
Như ghi chú bên trên 1 là nó thực hiện việc lấy dữ liệu từ bộ nhớ ở địa chỉ 940 đưa vào bộ nhớ tạm thời ở thanh ghi AC.
Bước 3:
Đọc từ thanh ghi PC lấy lệnh tiếp theo để thực thi ở đây nó lấy lệnh ở địa chỉ 301 đưa vào thanh ghi IR
Ở đây lệnh có giá trị là 5941 cũng như giải thích bên trên lệnh này có ý nghĩa là cộng vào thanh ghi AC với giá trị lấy từ địa chỉ 941 ,giá trị đó ở đây là 2.
Bước 4:
Đưa địa chỉ lệnh tiếp theo cần thực thi vào thanh ghi PC.
Thực hiện phép cộng 3+2=5 tại thanh ghi AC như hình ta được giá trị 5.
Bước 5:
Đọc từ thanh ghi PC lấy lệnh tiếp theo để thực thi ở đây nó lấy lệnh ở địa chỉ 302 đưa vào thanh ghi IR
ở đây lệnh có giá trị là 2941 cũng như giải thích trên lệnh này có ý nghĩa là lưu thanh ghi AC vào bộ nhớ ở địa chỉ 941
Bước 6:
Thực thi lệnh lưu 0005 vào bộ nhớ 941.
Đó là quá trình thực thi chương trình của bộ nhớ và các thanh ghi hệ Hexa
2. Giải thích quá trình thực thi lệnh của hệ thống khi có ngắt, Figure 1.7, trang 16, William Stallings, “Operating Systems”, 7th edition, 2012.
Ngắt là các lệnh cần thực thi mà không phải báo trước.
Bước 1: Lấy lệnh để thực thi.
Bước 2: Thực thi lệnh có 3 trường hợp
– Trường hợp 1 : Nếu không có ngắt xảy ra thì lệnh sẽ được đưa về hàng đợi chờ thực thi tiếp
– Trường hớp 2 : Nếu ngắt xảy ra thì lệnh sẽ được đưa vào trạng thái ngắt (trạng thái chờ ) và thực thi trạng thái chờ đó ,cho đến khi trạng thái chờ được gọi đến đưa vào hàng đợi để chờ cho đến khi nó được gọi để thực thi.
– Trường hợp 3 : Nếu lệnh đó đã hoàn thành thì dẫn đến kết thúc việc thực thi đoạn lệnh đó.
3. Giải thích về các loại bộ nhớ, Figure 1.14, trang 25, William Stallings, “Operating Systems”, 7th edition, 2012.
Càng tiến dần lên đỉnh tháp thì vùng nhớ càng nhỏ nhưng tốc độ lại càng nhanh và giá cả mắc hơn, tần suất truy cập với vi xử lý nhiều hơn.
Càng tiền dần về chân tháp thì vùng nhớ càng lớn nhưng tốc độ càng chậm và giá cả rẻ hơn, tần suất truy cập với vi xử lý it hơn.
Inboard memory là các bộ nhớ được gắn trực tiếp trên bo mạch chủ gồm có Registers (các thanh ghi), Cache (Bộ nhớ đệm Cache), Main memory bộ nhớ chính (RAM)
Outboard storage là các bộ nhớ lưu trữ nắm ngoài bo mạch chủ (local secondary storage) như đĩa cứng, đĩa mềm,và các loại đĩa quang CD-ROM..v..v
Off-line storage là các bộ lưu trữ nằm ngoài.
4. Hiểu về kiến trúc hệ thống Corei7 của Intel, Figure 1.20, trang 36, William Stallings, “Operating Systems”, 7th edition, 2012.
Một ví dụ của hệ thống đa lõi là Intel Core i7, bao gồm 4 vi xử lý x86, mỗi vi xử lý có 1 L2 cache dành riêng, và một L3 cache dùng chung. Một cơ chế mà Intel sử dụng để tạo ra các bộ nhớ đệm hiệu quả là việc lấy lại dữ liệu từ bộ nhớ đệm, trong mỗi lần duyệt phần cứng để tìm dữ liệu các dữ liệu này sẽ được cho vào các bộ nhớ đệm khi có yêu cầu tìm dữ liệu mà đã được yêu cầu trước đó thì chỉ tìm lại trong bộ nhớ đệm.
Chip Core i7 hỗ trợ 2 hình thức giao tiếp bên ngoài với những chip khác.
DDR3 memory controller: điều khiển lưu lượng dữ liệu từ bộ nhớ chính vào chip, nó hỗ trợ 3 kênh giao tiếp với mỗi kênh có độ rộng 8 bytes và tổng độ rộng bus là 192 bits, tổng lưu lượng dữ liệu lên đến 32 GB/s.
QuickPath Interconnect (QPI): là một liên kết điểm tới điểm với nhiều kết nối điện đặc biệt. Nó cho phép giao tiếp với tốc độ cao giữa kết nối với các chip vi xử lý. Liên kết QPI vận hành với tốc độ 6.4 GT/s (stransfers per second).
5. Mô tả “Mô hình tiến trình năm trạng thái”.
Null → New: Một tiến trình mới được sinh ra để thực thi một chương trình.
Ví du:
-Một dãy công việc mới yêu cầu thực hiện.
-Người dùng đăng nhập vào hệ thống.
New → Ready: Hệ điều hành sẽ chuyển đổi tiến trình từ trạng thái New sang trạng thái Ready khi nó được chuẩn bị được thêm vào hàng đợi.
Ready→ Running: Khi tiến trình được chọn để chạy, Hệ điều hành sẽ chọn một trong các tiến trình ở trạng thái Ready. Đó là công việc của bộ phận lập lịch và điều phối.
Running→ Exit: Tiến trình hiện tại đang thực thi được chấm dứt bởi hệ điều hành nếu tiến trình đó đã hoàn tất, hoặc là nó bị hủy vì lý do.
Ví dụ:
-Tiến trình hoàn tất.
-Vượt quá giời hạn thời gian.
-Tràn bộ nhớ.
-Truy cập trái phép đến vùng nhớ không được cho phép truy cập.
-Sử dụng tài nguyên trái phép.
-Chia với số 0.
-Đợi chờ vô hạn định.
-Lỗi nhập xuất.
-Thực thi lệnh không tồn tại.
-Tiến trình cha chấm dứt.
-Tiến trình cha yêu cầu chấm dứt.
Running → Ready: Đây là lý do chung cho những tiến trình đang chạy nhưng đã hết thời hạn cho phép.
Running → Blocked: Một tiến trình được đưa vào trạng thái Blocked nếu như gặp một tác vụ con xuất hiện thì tiến trình phải chờ để hoàn thành tác vụ con.
Blocked→ Ready: Một tiến trình ở trạng thái Blocked được chuyển sang trạng thái Ready khi tác vụ con đã hoàn tất.
Ready→Exit: Nếu tiến trình cha chấm dứt, tất cả tiến trình con liên quan với tiến trình cha đó cũng chấm dứt theo.
Blocked→Exit: Cũng tương tự trạng thái từ Ready→Exit.
I. Giải Thuật First Come First Serve (FCFS)
Ví dụ: Xét 4 tiến trình P1, P2, P3,P4 đến tại thời điểm 0, với thời gian xử lý được tính bằng mili giây.
P4→P3→P2→P1→CPU.
Bảng thời gian xử lý:
|
Quá trình |
Thời gian xử lý |
|
P1 |
24 |
|
P2 |
4 |
|
P3 |
4 |
| P4 |
5 |
Bảng thời gian chờ:
Vì các tiến trình đến cùng thời điểm tại t0=0 nên
|
P1 |
P2 | P3 |
P4 |
|
|
P1 |
– | 24 | 24 |
24 |
|
P2 |
– | – | 4 |
4 |
|
P3 |
– | – | – |
4 |
|
P4 |
– | – | – |
– |
Thời gian chờ TB: (0 + 24 +28 +32 ) / 4 = 21 (ms).
Lược đồ Gantt :
|
P1 |
P2 | P3 |
P4 |
0 24 28 32 37
II. Giải Thuật Shortest Job First (SJF)
Ví dụ 1: Xét 4 tiến trình P1, P2, P3,P4 đến tại thời điểm 0, với thời gian xử lý được tính bằng mili giây.
P4→P3→P2→P1→CPU.
Bảng thời gian xử lý:
| Quá trình |
Thời gian xử lý |
|
P1 |
24 |
|
P2 |
4 |
|
P3 |
4 |
|
P4 |
5 |
Do đây là giải thuật SJF nên ta sắp xếp lại thứ tự đến CPU dựa vào thời gian xử lý, thời gian xử lý ngắn nhất thì được thực hiện trước tiên.
P1→P4→P3→P2→CPU.
| P2 | P3 | P4 |
P1 |
|
|
P2 |
– | 4 | 4 | 4 |
|
P3 |
– | – | 4 |
4 |
| P4 | – | – | – |
5 |
|
P1 |
– | – | – |
– |
Thời gian chờ TB: (4 + 8 + 13) / 4 = 6 (ms).
Lược đồ Gantt :
| P2 | P3 | P4 |
P1 |
0 4 8 13
Ví dụ 2:
|
Tiến Trình |
Thời Gian Đến |
Thời Gian Xử Lý |
|
P1 |
0 |
12 |
|
P2 |
1 |
5 |
|
P3 |
2 |
7 |
|
P4 |
3 |
3 |
Bảng thời gian chờ:
|
P1 |
P2 | P3 |
P4 |
|
|
T0 |
(-11) | – | – | – |
|
T1 |
1 | (-4) | – |
– |
| T2 | 1 | (-3) | 1 |
– |
|
T3 |
1 | (-2) | 1 | 1 |
|
T5 |
2 | (-0) | 2 | 2 |
| T6 | 1 | – | 1 |
(-2) |
| T8 | 2 | – | 2 |
(-0) |
|
T9 |
1 | – | (-6) | – |
|
T15 |
6 | – | (-0) | – |
| T16 | (-10) | – | – |
– |
| T26 | (-0) | – | – |
– |
Thời gian chờ TB: (15 + 0+ 7 + 3) / 4 = 6.25 (ms)
Lược đồ Gantt:
| P1 | P2 | P4 | P3 |
P1 |
0 1 6 9 16 27
Ví dụ 3:
|
Tiến Trình |
Thời Gian Đến |
Thời Gian Xử Lý |
|
P1 |
0 | 6 |
|
P2 |
1 |
3 |
| P3 | 2 |
4 |
| P4 | 2 |
2 |
Bảng thời gian chờ:
| P1 | P2 | P3 | P4 | |
|
T0 |
(-5) | – | – |
– |
| T1 | 1 | (-2) | – |
– |
|
T2 |
1 | (-1) | 1 | 1 |
|
T3 |
1 | (-0) | 1 |
1 |
| T4 | 1 | – | 1 |
(-1) |
|
T5 |
1 | – | 1 | (-0) |
| T6 | 1 | – | (-3) |
– |
|
T9 |
3 | – | (-0) | – |
| T10 | (-4) | – | – |
– |
|
T14 |
(-0) | – | – |
– |
Thời gian chờ TB: (9 + 0+ 4 + 2) / 4 = 3.75 (ms).
|
P1 |
P2 | P4 | P3 |
P1 |
0 1 4 6 10 15
III. Giải Thuật Priority (P)
Ví dụ: Xét 6 tiến trình P1, P2, P3,P4,P5,P6 mỗi tiến trình có mỗi độ ưu tiên khác nhau đến cùng tại thời điểm t0=0 với thời gian xử lý được tính bằng mili giây.
|
Quá Trình |
Thời gian xử lý |
Độ ưu tiên |
|
P1 |
5 | 6 |
|
P2 |
10 | 1 |
|
P3 |
15 | 5 |
| P4 | 6 |
4 |
| P5 | 2 |
2 |
| P6 | 4 |
3 |
Do đây là giải thuật P nên ta sắp xếp lại thứ tự đến CPU dựa vào độ ưu tiên, độ ưu tiên nhỏ thì được thực hiện trước tiên.
P1→P3→P4→P6→P5→P2→CPU
| P2 | P5 | P6 | P4 | P3 | P1 | |
|
P2 |
– | 10 | 10 | 10 | 10 | 10 |
| P5 | – | – | 2 | 2 | 2 |
2 |
|
P6 |
– | – | – | 4 | 4 |
4 |
| P4 | – | – | – | – | 6 |
6 |
|
P3 |
– | – | – | – | – |
15 |
|
P1 |
– | – | – | – | – |
– |
Thời gian chờ TB: (0 + 10 + 12 + 16 + 22 + 37)/6=16.16 (ms).
Lược đồ Gantt :
| P2 | P5 | P6 | P4 | P3 |
P1 |
0 10 12 16 22 37 42
IV. Giải Thuật Round Robin (RR)
Ví dụ 1: Xét 4 tiến trình P1, P2, P3,P4 đến tại thời điểm 0, với thời gian xử lý được tính bằng mili giây sử dụng thuật toán Round Robin (xoay vòng) để tính thời gian chờ trung bình.
|
Quá Trình |
Thời Gian Xử Lý |
|
P1 |
5 |
|
P2 |
20 |
| P3 |
11 |
| P4 |
8 |
Giả sử định mức thời gian là 10 mili giây.
Bảng thời gian chờ :
|
Thời Gian |
P1 | P2 | P3 | P4 |
|
T0 |
(-4) | 1 | 1 |
1 |
| T4 | (-0) | 4 | 4 |
4 |
|
T5 |
– | (-19) | 1 | 1 |
|
T15 |
– | (-10) | 9 | 9 |
| T16 | – | 1 | (-10) |
1 |
| T25 | – | 9 | (-1) |
9 |
|
T26 |
– | 1 | 1 | (-7) |
|
T32 |
– | 7 | 7 | (-0) |
| T33 | – | (-9) | 1 |
– |
| T42 | – | (-0) | 9 |
– |
| T43 | – | – | (-0) |
– |
Lược đồ Gantt:Thời gian chờ TB: (0+23+33+25)/4=20.25 (ms).
| P1 | P2 | P3 | P4 | P1 |
P3 |
0 5 16 26 33 43
Ví dụ 2:
|
Quá Trình |
Thời Gian Đến | Thời Gian Xử Lý |
|
P1 |
0 |
24 |
| P2 | 1 |
3 |
|
P3 |
2 |
3 |
Giả sử định mức thời gian là 4 mili giây.
|
P1 |
P2 |
P3 |
|
|
T0 |
(-23) | – | – |
|
T1 |
(-22) | 1 | – |
| T2 | (-21) | 1 |
1 |
| T3 | (-20) | 1 |
1 |
|
T4 |
1 | (-2) | 1 |
|
T6 |
2 | (-0) |
2 |
| T7 | 1 | – |
(-2) |
|
T9 |
2 | – | (-0) |
|
T10 |
(-19) | – |
– |
| T29 | (-0) | – |
– |
Thời gian chờ TB: (6 + 3 + 5) / 3 = 4.66 (ms).
|
P1 |
P2 | P3 |
P1 |
0 4 7 10 30
I. Nhập Cơ Sở Dữ Liệu
-- -- Cơ sở dữ liệu: `mybook` -- -- -------------------------------------------------------- -- -- Cấu trúc bảng cho bảng `theloai` -- CREATE TABLE `theloai` ( `MATL` varchar(10) NOT NULL, `TENTL` varchar(50) NOT NULL ) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4;
II. Tạo lớp DBConnection
package laptrinhcsdl;
import java.sql.Connection;
import java.sql.DriverManager;
import java.sql.SQLException;
import java.sql.Statement;
import java.util.logging.Level;
import java.util.logging.Logger;
public class DBConnection {
//Đối tượng connect
private Connection conn;
//Đối tượng statement
public Statement stm;
public DBConnection() throws ClassNotFoundException {
try {
//Tải driver
Class.forName("com.mysql.jdbc.Driver");
//Lấy kết nối
conn=DriverManager.getConnection("jdbc:mysql://localhost:3306/mybook?useUnicode=true&characterEncoding=UTF-8","root","");
stm=conn.createStatement();
} catch (SQLException ex) {
Logger.getLogger(DBConnection.class.getName()).log(Level.SEVERE, null, ex);
}
}
}
III. Giao diện và sự kiện
Code tham khảo: (có sửa đổi)
package laptrinhcsdl;
import java.awt.BorderLayout;
import java.awt.GridLayout;
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;
import java.awt.event.MouseAdapter;
import java.awt.event.MouseEvent;
import java.sql.ResultSet;
import java.sql.SQLException;
import java.util.logging.Level;
import java.util.logging.Logger;
import javax.swing.BoxLayout;
import javax.swing.*;
import static javax.swing.JFrame.EXIT_ON_CLOSE;
import javax.swing.table.DefaultTableModel;
/**
*
* @author USER
*/
public class JFrameTheLoai extends JFrame implements ActionListener {
//Khai bao component
JLabel jlbMATL, jlbTENTL;
JTextField jtxtMATL, jtxtTENTL;
DefaultTableModel model;
JTable jtbTheLoai;
JButton jbtnThem, jbtnXoa, jbtnSua;
JPanel jpnTop, jpnCenter, jpnBottom, jpn1, jpn2;
DBConnection db;
public JFrameTheLoai() throws ClassNotFoundException {
super("LTCSDL");//dat ten
setSize(400, 500);
setLocationRelativeTo(null);//canh giua
setDefaultCloseOperation(EXIT_ON_CLOSE);//tac han chuong trinh
setLayout(new BorderLayout());
db = new DBConnection();
//Khoi tao component
jpnTop = new JPanel(new GridLayout(2, 1));
jpn1 = new JPanel();
jpn2 = new JPanel();
jpnCenter = new JPanel();
jpnBottom = new JPanel();
jlbMATL = new JLabel("MATL");
jlbTENTL = new JLabel("TENTL");
jtxtMATL = new JTextField(20);
jtxtTENTL = new JTextField(20);
jbtnThem = new JButton("Them");
jbtnSua = new JButton("Sua");
jbtnXoa = new JButton("Xoa");
model = new DefaultTableModel();
String[] columnsName = {"MATL", "TENTL"};
model.setColumnIdentifiers(columnsName);
LoadData();
jtbTheLoai = new JTable();
jtbTheLoai.setModel(model);
//Them conponent
jpn1.add(jlbMATL);
jpn1.add(jtxtMATL);
jpn2.add(jlbTENTL);
jpn2.add(jtxtTENTL);
jpnTop.add(jpn1);
jpnTop.add(jpn2);
add(jpnTop, BorderLayout.NORTH);
add(new JScrollPane(jtbTheLoai), BorderLayout.CENTER);
jpnBottom.add(jbtnThem);
jpnBottom.add(jbtnSua);
jpnBottom.add(jbtnXoa);
add(jpnBottom, BorderLayout.SOUTH);
//Thiet lap su kien
jbtnThem.addActionListener(this);
jbtnXoa.addActionListener(this);
jbtnSua.addActionListener(this);
jtbTheLoai.addMouseListener(new MouseAdapter() {
@Override
public void mouseClicked(MouseEvent me) {
jtxtMATL.setText(jtbTheLoai.getValueAt(jtbTheLoai.getSelectedRow(), 0).toString());
jtxtTENTL.setText(jtbTheLoai.getValueAt(jtbTheLoai.getSelectedRow(), 1).toString());
}
});
//Hien thi
setVisible(true);
}
private void LoadData() {
model.setNumRows(0);
try {
String sql = "SELECT * FROM theloai";
ResultSet rs = db.stm.executeQuery(sql);
while (rs.next()) {
String[] row = new String[2];
row[0] = rs.getString("MATL");
row[1] = rs.getString("TENTL");
model.addRow(row);
}
} catch (SQLException ex) {
Logger.getLogger(JFrameTheLoai.class.getName()).log(Level.SEVERE, null, ex);
}
}
public static void main(String[] args) throws ClassNotFoundException {
new JFrameTheLoai();
}
@Override
public void actionPerformed(ActionEvent ae) {
if (ae.getSource() == jbtnThem) {
try {
String sql = "INSERT INTO `theloai` (`MATL`, `TENTL`) VALUES ('" + jtxtMATL.getText() + "', '" + jtxtTENTL.getText() + "')";
db.stm.executeUpdate(sql);
LoadData();
} catch (SQLException ex) {
JOptionPane.showMessageDialog(null, ex, "Error", JOptionPane.ERROR_MESSAGE);
}
} else if (ae.getSource() == jbtnXoa) {
try {
String sql = "DELETE FROM `theloai` WHERE MATL='" + jtxtMATL.getText() + "'";
db.stm.executeUpdate(sql);
LoadData();
} catch (SQLException ex) {
JOptionPane.showMessageDialog(null, ex, "Error", JOptionPane.ERROR_MESSAGE);
}
} else if (ae.getSource() == jbtnSua) {
try {
String matl= model.getValueAt(jtbTheLoai.getSelectedRow(),0).toString();
String sql="UPDATE `theloai` SET `MATL`='"+jtxtMATL.getText()+"',`TENTL`='"+jtxtTENTL.getText()+"' WHERE MATL='"+matl+"'";
db.stm.executeUpdate(sql);
LoadData();
} catch (SQLException ex) {
JOptionPane.showMessageDialog(null, ex, "Error", JOptionPane.ERROR_MESSAGE);
}
}
}
}
I. Giao diện
II. Viết code
package Menu;
import java.awt.BorderLayout;
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;
import javax.swing.*;
public class FrameMenu extends JFrame implements ActionListener{
JMenuBar jmnubar;
JMenu jmnuFile;
JMenuItem jmnuiNew,jmnuiOpen,jmnuiExit;
public FrameMenu() {
setLayout(new BorderLayout());
setSize(300,400);
setDefaultCloseOperation(EXIT_ON_CLOSE);
jmnubar=new JMenuBar();
jmnuFile=new JMenu("File");
jmnuiNew=new JMenuItem("New");
jmnuiNew.setAccelerator(KeyStroke.getKeyStroke("ctrl N"));
jmnuiOpen=new JMenuItem("Open");
jmnuiOpen.setAccelerator(KeyStroke.getKeyStroke("ctrl O"));
jmnuiExit=new JMenuItem("Exit");
jmnuiExit.setAccelerator(KeyStroke.getKeyStroke("ctrl E"));
jmnuFile.add(jmnuiNew);
jmnuFile.add(jmnuiOpen);
jmnuFile.addSeparator();
jmnuFile.add(jmnuiExit);
jmnuFile.setMnemonic('F');
jmnubar.add(jmnuFile);
add(jmnubar,BorderLayout.NORTH);
jmnuiOpen.addActionListener(this);
jmnuiNew.addActionListener(this);
jmnuiExit.addActionListener(this);
setVisible(true);
}
public static void main(String[] args) {
new FrameMenu();
}
@Override
public void actionPerformed(ActionEvent ae) {
if(ae.getSource()==jmnuiOpen)
{
JOptionPane.showMessageDialog(null,"Open");
}
else if(ae.getSource()==jmnuiNew)
{
JOptionPane.showMessageDialog(null,"New");
}
else if(ae.getSource()==jmnuiExit)
{
JOptionPane.showMessageDialog(null,"Exit");
}
}
}
Võ Xuân Phong 