merge và xử lý lỗi conflic Pull Request trên Git

Hướng dẫn merge và xử lý lỗi conflic Pull Request trên Git

Giả sử chúng ta chưa có gì bây giờ muốn merge các pull request từ các lập trình viên. Hãy tạo một thư mục nào đó và click chuột phải vào thư mục đó chọn Git Bash. Tiếp theo đánh lệnh:

$ git init
$ git clone https://github.com/nukeviet/nukeviet.git -b develop .

Hai lệnh trên để thiết lập một kho mới và tải kho nukeviet về thư mục vừa tạo. Khi clone xong mặc định sẽ chọn nhánh develop. (chú ý có dấu chấm ở cuối trong câu lệnh git clone, nếu không nó sẽ tạo vào trong 1 thư mục nữa )

Bây giờ ta tiếp tục nhập lệnh sau:

$ git remote add vuthao https://github.com/vuthao/nukeviet.git
$ git fetch vuthao
$ git merge vuthao/develop

3 lệnh đó sẽ thực hiện việc tạo một nhánh ảo từ thành viên vuthao trên github sau đó lấy toàn bộ pull request của thành viên đó, nhập nhánh develop của vuthao vào nhánh đang làm việc của kho code hiện tại (tức nhánh develop của nukeviet).

Nếu quá trình merge tự động diễn ra thành công ta chỉ cần thực hiện lệnh

$ git push origin develop

Để hoàn tất việc merge pull request

Nếu merge bị conflic thì ta phải xử lý các file conflic trước, sau đó đưa vào index, commit rồi mới push lên kho code. Thứ tự thực hiện như sau.

Để xem thử conflic chỗ nào ta đánh

$ git diff

Khi đó các file bị conflic sẽ hiển thị đoạn code lỗi. Ta chỉ cần mở các file đó lên, chỉnh sửa đoạn code đó. Sau khi chỉnh sửa xong ta add file đó vào index bằng cách dùng lệnh

$ git add [file]

trong đó [file] là đường dẫn đến file ví dụ

$ git add modules/news/admin/content.php

Để xem trạng thái các file, thư mục … dùng lệnh

$ git status

Để hiển thị status gọn hơn ta dùng option -s

$ git status -s

Sau khi đã hoàn tất xử lý conflic … ta commit các chỉnh sửa vừa rồi:

$ git commit -m "Message"

Trong đó message là nội dung commit. Cuối cùng là push lên kho code.

$ git push origin develop

Một số lệnh git khác

Để tạm thời bỏ qua những thay đổi trong một tập tin nhất định, không muốn tập tin đó hiển thị trong các file thay đổi sử dụng lệnh:

git update-index --assume-unchanged path_file

Trong NukeViet Không đưa các file sau lên kho code khi có thay đổi .htaccess data/config_global.php data/ip_files/*.php

Sau đó, khi muốn tập tin đó hiển thị trong các file thay đổi:

git update-index --no-assume-unchanged path_file

Thay đổi commit message cuối

git commit -a --amend -m "My new commit message"

Reset project về ID trước đó

git reset --hard idcommit

Sau đó dùng lệnh sau để cập nhật lên kho git

fix commit: git push -f

fix merge conflicts in Git?

git mergetool

Liệt kê tất cả các file thay đổi từ id 3bf2d29 đến id b2d0398

git diff-tree -r --name-only 3bf2d29 b2d0398

Liệt kê tất cả các file đã xóa từ id 3bf2d29 đến id b2d0398

git diff-tree -r --name-only --diff-filter=D 3bf2d29 b2d0398

Zip lại các file thay đổi từ id 3bf2d29 đến id b2d0398 (không có file đã xóa)

git archive -o update1.zip HEAD $(git diff-tree -r --name-only --diff-filter=ACMRT 3bf2d29 b2d0398)

Ghi chú: Các option của diff-filter –diff-filter=[ACDMRTUXB*]

  A Added
  C Copied
  D Deleted
  M Modified
  R Renamed
  T have their type (mode) changed
  U Unmerged
  X Unknown
  B have had their pairing Broken
  * All-or-none

Xóa 1 nhánh trên kho code

git push origin --delete BRANCH_NAME

Đưa các tag được đánh dầu lên kho code

git push --tags

Read More

Sự thú vị của những con số trong toán học ít ai biết tới ?

1. Cặp số thân thiết

Hai số tạo thành một cặp số thân thiết khi chúng tuân theo quy luật: Số này bằng tổng tất cả các ước của số kia (trừ chính số đó) và ngược lại. Cặp số thân thiện đầu tiên được tìm ra, và cũng được chứng minh là cặp "số thân thiết" nhỏ nhất, là cặp số: 220 và 284. Hãy thử phân tích một chút: Số 220 ngoài bản thân nó ra, nó còn có 11 ước số là 1, 2, 4, 5, 10, 11, 20, 44, 55 và 110. Tổng của 11 ước số này vừa đúng bằng 284. Ngược lại, số 284 ngoài bản thân nó, nó còn 5 ước số khác là: 1, 2, 4, 71, 142, tổng của chúng cũng vừa đúng bằng 220.

Thế kỷ 17, nhà toán học Pháp Fecma tìm ra cặp "số thân thiết" thứ hai là:17296 và 18416. Cũng thời điểm ấy, một nhà toán học Pháp khác tìm ra cặp số thứ ba là: 9363544 và 9437056. Điều khiến người ta kinh ngạc nhất là nhà toán học Thuỵ Sỹ nổi tiếng Ơ-le vào năm 1750 đã công bố một lúc 60 cặp số thân thiết. Giới toán học được một phen kinh hoàng, họ cho rằng: "Ơ-leđã tìm ra hết cả rồi". Nhưng không ngờ, một thế kỷ sau, một thanh niên nước Ý mới 16 tuổi tên là Baconi đã công bố một cặp số thân thiết vào năm 1866, nó chỉ lớn hơn 220 và 284 một chút, đó là cặp số 1184 và 1210. Những nhà toán học lớn trước đó đã tìm ra chúng, để cho cặp số chẳng mấy lớn này dễ dàng qua mặt.

Cùng với sự phát triển của khoa học kỹ thuật, các nhà toán học bằng máy tính đã kiểm tra tất cả các số trong phạm vi 1.000.000, tổng cộng tìm được 42 cặp số thân thiết. Hiện nay, số lượng cặp số thân thiết được tìm thấy đã vượt quá con số 1000. Thế nhưng liệu có phải số thân thiết là nhiều vô hạn? Chúng phân bố có quy luật không? Những vấn đề này tới nay vẫn còn bỏ ngỏ.

Với thời đại công nghệ hiện nay, chỉ bằng một thuật toán C++ không quá phức tạp, bạn có thể tìm được rất rất nhiều các cặp số thân thiết.

2. Cặp số hứa hôn

Không chỉ dừng lại ở mức thân thiết, tiến thêm một bước nữa, các nhà khoa học bắt đầu định nghĩa “số hứa hôn”.

Cặp số hứa hôn là hai số nguyên dương sao cho: tổng các ước của số này (không tính số đó) nhiều hơn số kia đúng 1 đơn vị. Nói cách khác, (m, n) là một cặp số đã đính hôn nếu s (m) = n + 1 và s (n) = m + 1, trong đó s (n) là tổng phần nổi của n: một điều kiện tương đương là đó σ (m) = σ (n) = m + n + 1, trong đó σ biểu thị chức năng tổng các ước.

Những cặp số hứa hôn đầu tiên đã được tìm ra: (48, 75), (140, 195), (1050, 1925), (1575, 1648), (2024, 2295), (5775, 6128).

Người ta chứng minh được rằng, cặp số hứa hôn luôn gồm 1 số chẵn và 1 số lẻ ( có lẽ là tượng trưng cho 1 nam và 1 nữ).

3. Emirp

Nếu bạn đang cố tra từ trên trong tiếng anh thì chắc sẽ không tìm thấy đâu. Bởi nó là từ viết ngược của từ “Prime”.

Một emirp là một số nguyên tố mà khi đảo ngược vị trí các chữ số của nó, ta cũng được một số nguyên tố. Định nghĩa này không bao gồm các số nguyên tố xuôi ngược (như 151 hoặc 787), cũng không phải số nguyên tố 1 chữ số như 7.

Những emirps đầu tiên được tìm ra là: 13, 17, 31, 37, 71, 73, 79, 97, 107, 113, 149, 157...

Tính đến tháng 11 năm 2009, các emirp lớn nhất được biết đến là 1.010.006 941.992.101 × 104.999 1, được tìm thấy bởi Jens Kruse Andersen trong tháng 10 năm 2007.

4. Số hoàn hảo

Trong lý thuyết số, một số nguyên dương được gọi là số hoàn hảo khi nó bằng tổng tất cả các ước nguyên dương của nó, trừ chính nó. Hoặc một định nghĩa khác, Một số được gọi là hoàn hảo khi nó bằng nửa tổng các ước nguyên dương của nó (tính cả chính nó). Chẳng hạn, số hoàn hảo đầu tiên là 6, vì: 6 = 1 + 2 + 3, hoặc 6 = (1 + 2 + 3 + 6)/2.

Về mặt lịch sử, bốn số hoàn hảo đầu tiên: 6, 28, 496 và 8128 đã được biết đến từ lâu trong toán học Hy Lạp do nhà toán học Nicomachus tìm ra. Trong một bản thảo bằng văn bản giữa 1456 và 1461, một nhà toán học vô danh đã đưa ra số hoàn hảo thứ năm: 33.550.336. Năm 1588, nhà toán học người Ý Pietro Cataldi xác định (8589869056) và (137.438.691.328) là các số hoàn hảo thứ sáu và thứ bảy.

Euclid đã chứng minh rằng 2n−1(2n − 1): là một số hoàn hảo khi 2p-1 là số nguyên tố. Để 2n-1 là số nguyên tố, thì n cũng phải là số nguyên tố. Ví dụ: n = 2 => 2* (2^2-1) = 6; n= 3=> 2^2 (2^3-1) = 28. Số nguyên tố có dạng 2n-1 được gọi là số nguyên tố Mersenne, lấy theo tên của mười bảy tu sĩ Marin Mersenne, những người nghiên cứu lý thuyết số và số hoàn hảo. Cho đến thế kỷ 18 mà Leonhard Euler đã chứng minh: “mỗi nguyên tố Mersenne tạo ra một số hoàn hảo, và ngược lại, mỗi số hoàn hảo tương ứng với 1 số nguyên tố Mersenne”. Kết quả này thường được gọi là Định lý Euclid-Euler.

Tính đến tháng 2 năm 2013, 48 số nguyên tố Mersenne và do đó, 48 số hoàn hảo đã được biết đến. Số lớn nhất trong số này là 257.885.160 x (257.885.161-1) với 34.850.340 chữ số.

5. Số mạnh mẽ

Nguồn gốc của cái tên này xuất phát từ sự tích gót chân Achilles. Là một vị anh hùng chiến tranh đầy sức mạnh, chỉ có một điểm yếu duy nhất là gót chân. Có lẽ từ đây, người ta mới đưa ra phân biệt ba thuật ngữ: số hoàn hảo, số Achilles, và số mạnh mẽ.

Một số được gọi là số mạnh mẽ khi nó đồng thời vừa chia hết cho số nguyên tố và chia hết cho bình phương của số nguyên tố đó. Chẳng hạn, số 25 là số mạnh mẽ, vì nó vừa chia hết cho số nguyên tố 5, và bình phương của 5 (tức 25). Như vậy, một số mạnh mẽ, cũng có thể trùng với một số hoàn hảo (số hoàn hảo được định nghĩ như trên).

Một số Achilles là số mạnh mẽ, nhưng không phải là số hoàn hảo.

Sau đây là một danh sách của tất cả các con số mạnh mẽ giữa 1 và 1000: 1, 4, 8, 9, 16, 25, 27, 32, 36, 49, 64, 72, 81, 100, 108, 121, 125, 128, 144, 169, 196, 200, 216, 225, 243, 256, 288, 289, 324, 343, 361, 392, 400, 432, 441, 484, 500, 512, 529, 576, 625, 648, 675, 676, 729, 784, 800, 841, 864, 900, 961, 968, 972, 1000.

6. Số kì quặc

Để hiểu số kì quặc là gì, ta cần đi qua hai định nghĩa: Số phong phú và số bán hoàn hảo.

Số phong phú là các số mà tổng các ước số của số đó (không kể chính nó) lớn hơn số đó. Ví dụ, số 12 có tổng các ước số (không kể 12) là 1 + 2 + 3 + 4 + 6 = 16 > 12. Do đó 12 là một số phong phú.

Số bán hoàn hảo là số tự nhiên bằng tổng tất cả hoặc một số ước của nó. Như vậy, tập số bán hoàn hảo rộng hơn tập số hoàn hảo. Một số số bán hoàn hảo: 6 , 12 , 18 , 20 , 24 , 28 , 30 , 36 , 40…

Như vậy, giữa hai tập hợp số bán hoàn hảo và số phong phú có các phần tử chung.

Và cuối cùng, số kì quặc là gì? Một số là số kì quặc nếu nó là số phong phú nhưng không phải là số bán hoàn hảo. Nói cách khác, tổng các ước của nó là lớn hơn số đó, nhưng tổng của một số hoặc tất cả các ước không bao giờ bằng số đó.

Vài số đầu tiên trong tập hợp số kì quặc là: 70, 836, 4030, và 5830.

7. Số hạnh phúc

Một số hạnh phúc được xác định bởi quá trình sau đây:

Bắt đầu với bất kỳ số nguyên dương, thay thế số bằng tổng các bình phương các chữ số của nó, và lặp lại quá trình cho đến khi số bằng 1 (nơi mà nó sẽ ở lại), hoặc nó lặp vô tận trong một chu kỳ mà không bao gồm 1.

Những con số mà quá trình này kết thúc trong 1 là những con số hạnh phúc, trong khi những người không kết thúc trong 1 là những con số không hài lòng (hoặc số buồn).

Hãy cùng thử với số 44:

+ Thứ nhất, 4 ^ 2 + 4 ^ 2 = 16 + 16 = 32.

+ Tiếp theo: 3 ^ 2 + 2 ^ 2 = 9 + 4 = 13.

+ Và một lần nữa: 1 ^ 2 + 3 ^ 2 = 1 + 9 = 10.

+ Cuối cùng: 1 ^ 2 + 0 ^ 2 = 1 + 0 = 1.

Đó là một số hạnh phúc.

Điều thú vị là số hạnh phúc là rất phổ biến, có 143 số từ 0 đến 1000. Và số hạnh phúc lớn nhất với không có chữ số lặp lại là: 986.543.210. Đó là một con số hạnh phúc thực sự.

8. Số bất khả xâm phạm

Cái tên kì quặc này được đặt cho những số “không thể” viết dưới dạng tổng tất cả các ước của một số nguyên dương bất kì (không tính số nguyên dương đó).

Chẳng hạn, 4 không phải là số bất khả xâm phạm vì 4= 3+1. Trong đó 3 và 1 là tất cả các ước của 9. Còn 5 là số bất khả xâm phạm vì cách duy nhất viết 5 = 4+1. Nếu bạn lý luận đây là tổng ước của 4 thì bạn nhầm. Vì tổng các ước của 4 phải là: 1+2=3.

Các số bất khả xâm phạm đầu tiên: 2, 5, 52, 88, 96, 120, 124, 146, 162, 188, 206, 210, 216, 238, 246, 248, 262, 268, 276, 288, 290…

9. Số tự mãn

Số tự mãn là những số bằng tổng các mũ bậc ba của mỗi chữ số của nó. VD:

153 = 1 ^ 3 + 5 ^ 3 + 3 ^ 3.
370 = 3 ^ 3 + 7 ^ 3 + 0 ^ 3.
371 = 3 ^ 3 + 7 ^ 3 + 1 ^ 3.
407 = 4 ^ 3 + 0 ^ 3 + 7 ^ 3..

Các con số, khi được đặt tên bởi các nhà khoa học, chính bản thân họ cũng nhận ra sự phù phiếm của chúng. Nhà toán học anh, GH Hardy thậm chí đã công bố trong cuốn sách "Lời xin lỗi của toán học": "Đây là những khái niệm kỳ lạ, rất thích hợp cho các cột câu đố và có khả năng để giải trí, nhưng không có gì hấp dẫn đối với các nhà toán học". Dẫu sao, cũng xin đưa đến người đọc một góc nhìn mới về toán học.

Read More

How To Earn Money With Tsu ?

VD: có bốn người sử dụng A, B, C và D. A mời B, B mời C, C mời D.
Người sử dụng D chia sẻ một bức ảnh giúp Tsu kiếm được $100 tiền quảng cáo.
Tsu giữ $10 cho hoạt động của họ và chia sẻ phần còn lại, 90$ với người sử dụng.
Người dùng D, người đã chia sẻ bức ảnh sẽ nhận được 50% số $ 90, có nghĩa là 45 $.
Người dùng C, người đã mời người dùng D sẽ nhận được 33,3% (1/3) giá trị ban đầu $ 90, có nghĩa là $ 29,70.
Người dùng B, người đã mời người dùng C sẽ nhận được 11,1% (1/3*1/3 = 1/9) giá trị ban đầu $ 90, có nghĩa là $ 9,99
Người dùng A, người đã mời người dùng B sẽ nhận được 3,70% (1/3*1/3*1/3 = 1/27) của giá trị ban đầu $ 90, có nghĩa là $ 3,33.

Read More

Thread và Tại sao không dùng nhiều processes , sao không là multiprocessing mà lại cần đến multithreading ?

Thread là một dòng các điều khiển trong một process hay một ứng dụng. Nguyên văn là : Threads are multiple flows of control within a single program or process.

Với cơ chế multithreading ứng dụng của ta có thể thực thi đồng thời nhiều dòng lệnh cùng lúc. Có nghĩa là ta có thể làm nhiều công việc đồng thời trong cùng một ứng dụng của ta. Có thể hiểu một cách hết sức đơn giản : hệ điều hành với cơ chế đa nhiệm cho phép nhiều ứng dụng chạy cùng lúc. Thì với cơ chế đa luồng, mỗi ứng dụng của ta có thể thực hiện được nhiều công việc đồng thời.

Tại sao không dùng nhiều processes , sao không là multiprocessing mà lại cần đến multithreading ?

Câu trả lời đơn giản nhất là: Việc tạo ra và quản lý các process đòi hỏi nhiều tài nguyên của hệ thống (cả ram và CPU) nhiều hơn rất nhiều so với việc tạo ra một thread. Trong khi đó có thể chỉ cần tạo ra một thread để thực hiện song song một công việc hết sức đơn giản cùng với một công việc chính.

Viết một ứng dụng Java trên bất kỳ nền tảng nào. Khi ứng dụng ,ta chạy thì thực sự đã có một bản sao của JVM khởi động và ứng dụng của ta là một thread nếu ta không dùng multithreading hoặc là nhiều threads nếu tadùng multithreading.

Tạo một threadNhư đã nói, mỗi khi chạy một ứng dụng trong java thì đã có một thread. Đây là thread chính, nó thực thi các dóng lệnh trong method : public static void main . Đây là một điểm nhập bắt buộc cho mọi ứng dụng độc lập.

Để tạo ra một thread khác ngoài thread chính trên, Java cung cấp cho chúng ta hai cách :

- Tạo ra một lớp con của lớp Thread (java.lang.Thread)

- Tạo ra một lớp hiện thực interface Runnable

Chúng ta sẽ tìm hiểu lần lược hai cách trên.

Tạo một lớp con của lớp java.lang.Thread

Bạn khai báo như sau :

class A extends Thread {

public void run() {

... // code for the new thread to execute

}

}

...

A a = new A(); // create the thread object

a.start(); // start the new thread executing

...

Với cách này các dòng lệnh sẽ được đặt trong method run. Method này được override method nguyên thuỷ của lớp Thread.

Sau đó ta sẽ tạo ra một đối tượng từ lớp của ta.

Gọi phương thức start từ đối tượng đó. Lúc này thread của ta chính thức được tạo ra và phương thức start sẽ tự gọi method run của tavà thực thi các dòng lệnh mà đã đặc tả.

Chú ý rằng: method start là method của hệ thống, nó có nhiệu vụ cấp phát bộ nhớ, tạo ra một thread và gọi hàm run của ta. Vì thế không nên override phương thức này. Điều này có thể dẫn đến ko tạo được thread.

Hiện thực interface Runnable
Khai báo như sau:

class B extends … implements Runnable {

public void run() {

... // code for the new thread to execute

}

}

...

B b = new B(); // create the Runnable object

Thread t = new Thread(b); // create a thread object

t.start(); // start the new thread

...

Cũng giống như cách trên, dòng lệnh đặt trong method run (có thể gọi đến các phương thức khác, nhưng phải bắt đầu trong phương thức này)

Sau đó tạo một đối tượng B từ lớp đã hiện thực interface Runnable, tạo thêm một đối tượng t của lớp Thread với thông số cho constructor là đối tượng B.

Sau đó khi gọi phương thức t.start() thì chính thức thread được tạo ra và phương thức run sẽ được triệu gọi một cách tự động.

Bạn sẽ hỏi tại cách thứ hai vẫn phải tạo ra một đối tượng Thread. Vậy tại sao lại đưa ra hai cách hiện thực làm gì ?

Câu trả lời là :

- Bản thân ngôn ngữ Java không hỗ trợ đa thừa kế . Bạn chỉ có thể extends từ một lớp duy nhất. Nhưng bạn lại có thể implements cùng lúc nhiều interface. Khi mà lớp của ta đã [extends] một lớp nào đó rồi (vd : Applet), thì chỉ có thể implements Runnable để tạo ra Thread.

- Việc extends lớp Thread có thể dẫn đến rủi ro là bạn override các method start, stop, ... thì có thể làm cho việc tạo thread là không thể.

Một lời khuyên là: nên tạo ra một lớp hiện thực interface Runnable (cách thứ hai) khi muốn tạo ra một Thread. Chương trình sẽ trong sáng và dễ tìm lỗi hơn.

-------------------------------

Việc đồng bộ hóa một method là cách tốt nhất để hạn chế việc sử dụng một method tại một thời điểm. Tuy nhiên sẽ có những trường hợp mà bạn không thể đồng bộ hóa một method, chẳng hạn như khi bạn sử dụng một class được cung cấp bởi bên thứ ba. Trong những trường hợp như thế, bạn không được phép truy cập vào định nghĩa lớp, sẽ ngăn bạn sử dụng từ khóa synchronized.

Sử dụng phát biểu được đồng bộ hoá

Một cách khác để sử dụng từ khóa synchronized là sử dụng phát biểu được đồng bộ hóa. Một phát biểu được đồng bộ hóa chứa một block được đồng bộ hóa , mà bên trong đó đặt những đối tượng và những method được đồng bộ hóa. Gọi các method chứa block được đồng bộ hóa xảy ra khi một thread có được monitor của đối tượng.
Mặc dù bạn có thể gọi những method bên trong một block được đồng bộ hóa, việc công bố method phải được thực hiện bên ngoài một block được đồng bộ hóa.
Ví dụ dưới đây chỉ cách làm thế nào để sử dụng một phát biểu được đồng bộ hóa. Ví dụ này cơ bản cũng giống ví dụ trước, tuy nhiên phát biểu được đồng bộ hóa được sử dụng thay vì từ khóa synchronized. Phát biểu này được đặt trong method run() của class MyThread. Phát biểu được đồng bộ hóa sẽ đồng bộ hóa instance của class Parentheses và vì thế ngăn hai thread sử dụng method display() cùng một lúc.
class Parentheses {
void display(String s) {
System.out.print (”(” + s);
try {
Thread.sleep (1000);
} catch (InterruptedException e) {
System.out.println (”Interrupted”);
}
System.out.println(”)”);
}
}

class MyThread implements Runnable {
String s1;
Parentheses p1;
Thread t;
public MyThread (Parentheses p2, String s2) {
p1= p2;
s1= s2;
t = new Thread(this);
t.start();
}
public void run() {
synchronized(p1){
p1.display(s1);
}
}
}

class Demo{
public static void main (String args[]) {
Parentheses p3 = new Parentheses();
MyThread name1 = new MyThread(p3, “Bob”);
MyThread name2 = new MyThread(p3, “Mary”);
try {
name1.t.join();
name2.t.join();
} catch (InterruptedException e ) {
System.out.println( “Interrupted”);
}
}
}

Ở đây, method display() không sử dụng từ khóa synchronized. Thay vào đó, phát biểu được đồng bộ hóa được sử dụng bên trong method run(). Điều này cho kết quả giống với ví dụ trước bởi vì một thread chờ một khoảng thời gian để thread còn lại kết thúc trước khi tiếp tục xử lý.

Giao tiếp giữa các thread

Các thread mở ra cho các lập trình viên một khoảng không mới trong lập trình, nơi mà ở đó những phần của một chương trình thực thi không đồng bộ với nhau, mỗi một xử lý độc lập với những xử lý khác. Tuy nhiên mỗi thread thỉnh thoảng cần tính toán việc xử lý của chúng và vì thế cần có thể giao tiếp với những thread khác trong suốt quá trình xử lý. Các lập trình viên gọi đây là inter-process communication (giao tiếp trong xử lý).
Bạn có thể có các thread giao tiếp với các thread khác trong chương trình của bạn bằng cách sử dụng những method wait(), notify() và notifyAll(). Những method này được gọi từ bên trong một method được đồng bộ hóa. Method wait() nói cho một thread giải phóng monitor và đi vào trạng thái suspend. Có hai dạng method wait() khác nhau. Một dạng không yêu cầu đối số và vì thế một thread sẽ chờ cho đến khi nó được thông báo. Một dạng khác có đối số để bạn xác định khoảng thời gian chờ. Bạn xác định độ dài thời gian trong mili giây và đặt nó vào trong method wait().
Method notify() nói cho một thread đang suspend bởi method wait() và lấy lại điều khiển của monitor. Method notifyAll() đánh thức tất cả các thread đang chờ điều khiển của monitor. Những thread khác chờ trong trạng thái suspend cho đến khi monitor có sẵn trở lại.
Ví dụ dưới đây chỉ cho bạn làm thế nào để sử dụng những method này trong một ứng dụng. Mục đích của chương trình là có một class Pulishser cho một giá trị cho class Consumer thông qua sử dụng class Queue. Ví dụ này định nghĩa bốn class, class Pulisher, class Comsumer, class Queue và class Demo. Class Queue định nghĩa hai instance: exchangeValue và một biến cờ. exchangeValue đặt vào một giá trị trong queue bởi publisher. Biến cờ được sử dụng như một cách đánh dấu giá trị được đặt vào trong queue. Class Queue cũng định nghĩa một method get() và một method put(). Method put() sử dụng để đặt một giá trị vào queue (gán một giá trị cho exchangeValue), method get() sử dụng để nhận giá trị chứa trong queue (trả về giá trị của exchangeValue. Khi một giá trị được gán, method put() thay đổi giá trị của biến cờ từ false thành true xác định một giá trị được đặt vào trong queue. Chú ý giá trị của biến cờ được sử dụng như thế nào trong method get() và method put() để có thread gọi method chờ cho đến khi có một giá trị trong queue hoặc không có giá trị nào trong queue, phụ thuộc vào method nào đang được gọi.
Class Publisher công bố một instance của class Queue và sau đó gọi method put() đặt vào năm số nguyên integer trong queue. Mặc dù method put() được đặt trong một vòng lặp for, mỗi số nguyên integer được đặt vào trong queue, và sau đó có một khoảng tạm dừng cho đến khi số nguyên integer được nhận bởi class Consumer.
Class Consumer tương tự như thiết kế class Publisher, ngoại trừ class Consumer gọi method get() năm lần bên trong một vòng lặp for. Mỗi lần gọi, method get() tạm dừng cho đến khi class Publisher đặt một số nguyên integer vào trong queue.
Method main() của class Demo tạo ra các instance của class Publisher, class Consumer và class Queue. Chú ý rằng các khởi dựng của của class Publisher và class Consumer đều đặt vào một reference đến instance của class Queue. Chúng sử dụng instance của class Queue cho inter-process communication.
Dưới đây là những gì mà bạn sẽ thấy khi chạy chương trình và mã nguồn của ví dụ
Put: 0
Get: 0
Put: 1
Get: 1
Put: 2
Get: 2
Put: 3
Get: 3
Put: 4
Get: 4

class Queue {
int exchangeValue;
boolean busy = false;
synchronized int get() {
if (!busy)
try {
wait();
} catch (InterruptedException e) {
System.out.println(
“Get: InterruptedException”);
}
System.out.println(”Get: ” + exchangeValue);
notify();
return exchangeValue;
}
synchronized void put (int exchangeValue) {
if (busy)
try {
wait();
} catch (InterruptedException e) {
System.out.println(
“Put: InterruptedException”);
}
this.exchangeValue = exchangeValue;
busy = true;
System.out.println(”Put: ” + exchangeValue);
notify();
}
}

class Publisher implements Runnable {
Queue q;
Publisher(Queue q) {
this.q = q;
new Thread (this, “Publisher”).start();
}
public void run() {
for (int i = 0; i < 5; i++){
q.put(i);
}
}
}

class Consumer implements Runnable {
Queue q;
Consumer (Queue q) {
this.q = q;
new Thread (this, “Consumer”).start();
}
public void run() {
for (int i = 0; i < 5; i++){
q.get();
}
}
}

class Demo {
public static void main(String args []) {
Queue q = new Queue ();
new Publisher (q);
new Consumer (q);
}
}

----------------------------------------------------------------------

----------------------------------------------------------------------

Điều phối các thread ngang hàng

HĐH điều phối tiến trình theo phương pháp phân chia cho mỗi tiến trình một khoảng thời gian delta t bằng nhau
Khi một tiến trình bị sleep thì tiến trình khác sẽ chiếm hữu CPU.

Các nguyên tắc khi lập trình thread trong java
Nguyên tắc đầu tiên các bạn nên nhớ đó là không có khái niệm chạy đồng thời. Chúng ta thường nghe nói các thread có thể chạy đồng thời nhưng thực ra đó là cách nói của những vắn tắt của những chuyên gia. Và khi đến tai của chúng ta thì nó đã bị chính các bạn hiểu một cách sai lệch là CPU xử lý đồng thời 2 tiến trình nhưng thực ra trong một thời điểm thì CPU chỉ có thể xử lý được một công việc duy nhất hay nói cách khác là một phép toán duy nhất. Sở dĩ chúng ta có thể thấy 2 kết quả xuất hiện đồng thời khi bạn cho 2 thread chạy với một thời gian sleep như nhau là vì chúng ta không cảm nhận được khoảng thời gian nhường quyền được xử lý giữa 2 thread đó. Giả sử ta có 2 thread ngang hàng A, B. A cho sleep (10000) và B cũng sleep(10000) tức là 10 giây. Sau 10 giây bạn sẽ thấy 2 kết quả xuất hiện đồng thời. Để có thể lý giải được điều này thì mời bạn đọc tiếp. (1)

Thứ 1: Khi hhông sử dụng hàm sleep trong phương thức run của A và B
 Các thread sẽ chạy tuần tự. Tức là thread nào khởi tạo trước thì chạy trước, thread nào khởi tạo sau thì chạy sau.
Thứ 2:
Khi sử dụng hàm sleep thì 2 thread A và B sẽ được phân phối dựa theo thời gian sleep của mỗi thread. Thời gian sleep được tính bắt đầu từ lúc bắt đầu khởi chạy và lúc một thread vừa được xử lý xong và bắt đầu chuyển sang trang thái sleep.

Mặc dù hàm sleep(int a) phải truyền vào tham số là một số nguyên dương hoặc 0 nhưng thực ra nếu truyền vào giá trị là 0 thì cũng không có nghĩa là tương đương với việc không sử dụng hàm sleep.
Nên nhớ rằng sleep(0) khác với không sử dụng hàm sleep. Mặc dù đối truyền vào là 0 nhưng thực ra CPU vẫn dành ra một khoảng thời gian > 0 & < 1 (mili giây) để phân phối cho thread đó.
Vì vậy mà nếu A dùng sleep(0) và B dùng sleep(1) thì số lần A được CPU xử lý hiều hơn B và tất nhiên là A sẽ có nhiều kết quả đầu ra hơn B.

Tôi có thể lý giải vấn đề này một cách cụ thể và logic hơn như sau:

+ A sleep(0) nhưng CPU tính là nó sleep trong một khoảng thời gian là delta t với t < 1 mili giây. Tôi giả sử là delta t = 1/3 mili giây.
+ B sleep(1) thì CPU tính là sleep trong 1 mili giây.
Khi bạn cho chạy 2 thread A và B thì CPU sẽ xử lý như sau (giả sử A khởi tạo trước):
A được CPU xử lý trong quá trình đó thì tất cả các thread khác sẽ bị khoá trong vòng 1/3 mili giây. Sau 1/3 mili giây thì B vẫn đang bị khoá nên A tiếp tục được xử lý và sau khi A được xử lý xong thì tổng thời gian sleep của A là 2/3 mili giây sau 3 lần chạy thì B đã ngủ đủ 1 mili giây B bắt đầu chạy. Trong khi đó thì A đang phải sleep tiếp 1/3 mili giây. Sau khi B xử lí xong thì A sẽ tiếp tục được xử lý nhưng nếu A được wakeup trong khi B đang được xử lí thì A sẽ đặt vào trạng thái chờ trong hàng đợi và sau khi B xử lý xong thì ngay lập thức A sẽ được xử lý... Và cứ như vậy ta có thể đưa ra một kết luận là sẽ không bao giờ có chuyện A cho ra nhiều hơn 3 kết quả liên tục và cũng không bao giờ có chuyện B cho ra nhiều hơn 1 kết quả liên tục.
Các bạn có thể kiểm chứng điều này bằng cách A cho sleep(1) và B cho sleep(3).
Bạn sẽ không bao giờ nhận được một kết quả như là:
A
A
A
A
B
hay là:
B
B
A

Nếu cả 2 thread A và B đều có thời gian sleep bằng nhau kể cả là sleep(0) thì các kết quả xử lý sẽ là xen kẽ nhau và bạn sẽ chẳng bao giờ nhận được một kết quả như là:
A
A
B
hoặc là:
B
B
A
mà chỉ có:
A
B
A
B
...
Đối với trường hợp này khi cả A và B sleep đủ thời gian thì cả 2 sẽ được wakeup để xử lý nhưng thread nào khởi tạo trước sẽ được ưu tiên xử lý trước. Thread chưa khi được wakeup mà CPU lại đang bận xử lý thread khác thì nó được đẩy vào hàng đợi. Do đó A, B nối đuôi nhau xử lý. A xử lý xong thì in ngay kết quả ra màn hình trong khi đo B cũng đang được xử lý và in ra kết quả ngay khi nó xử lý xong. Bây giờ bạn đọc lại phần đầu (1) và ngẫm lại thì sẽ hiểu vì sao lại gọi là xử lý đồng thời.

Read More

Cách khắc phục lỗi full disk trên win 8.1

1. Set Ram ảo bằng thủ công thay vì để chế độ Automatically:

Để Ram ở chế độ Automatically (tự động) cũng là một trong những nguyên nhân khiến máy tính bạn bị dính lỗi Full Disk. Thay vì để chế độ Auto thì bạn nên Set cứng RAM ảo. Cách thực hiện như ảnh ở dưới:

​Tại Tab Virtual Memory, bỏ dấu tick ở Automatically manage paging file size for all drives. Chọn ổ đĩa cài Hệ điều hành của bạn (thường là ổ C). Sau đó tích vào Custom size.

Tại mục Maximum size và Initial size. Bạn set cứng cho Ram ảo bằng 1/2 Ram thật của bạn. Ở đây mình có 4GB Ram nên sẽ Set một nửa là 2GB Ram = 2048MB, tương tự các bạn làm với máy tính của bạn.

Cuối cùng ấn OK để lưu, và khởi động để thay đổi có hiệu lực.

2. Xử lý Troubleshooting:

Bạn vào Control Panel, gõ Troubleshooting trên ô tìm kiếm và nhấn vàoTroubleshooting.

Cửa sổ mới hiện ra, kích đúp chuột vào System and Security:

Cửa sổ mới hiện ra, kích vào System Maintenance:

Nhấn Next:

Sau đó cứ để cho máy nó làm việc khi xuất hiện thông báo System Maintenance như hình thì nhấn vào mục Try troubleshooting as an administrator:

Sau đó ngồi đợi, chờ cho nó chạy đến khi nào có chữ Close thì nhấn vào.

3. Tắt Maintenance:

Cũng ở Control Panel, chọn System and Security và Action Center:

Tiếp theo nhấp chuột vào mũi tên đở phần thiết lập Maintenance, chọn Settings:

Bạn tích vào Never check for solutions (Not recommended) và OK:

4. Tắt Windows SmartScreen:

Vẫn ở cửa sổ Action Center, chọn Change Windows SmartScreen Settings, sau đó tích vào Don’t do anything (Turn off Windows SmartScreen).

 ​

5. Tắt Service Superfetch:

Các bạn ấn tổ hợp phím Windows + R để mở Run gõ Services.msc. Sau đó tìmSuperfetch (ấn S rồi tìm cho nhanh), kích đúp vào nó và chọn Disabled.

​6. Tắt Service Windows Search:

Các bạn cũng làm tương tự như trên nhưng tìm Windows Search (ấn W rồi tìm), kích đúp vào nó và chọn Disabled.

7. Tắt Disk Diagnostics: Configure execution level:

Các bạn vào Run gõ gpedit.msc. Sau đó tìm đến đường dẫn sau:

Computer Configuration / Adminnistrative Templates / System / Troubleshooting and Diagnostics / Disk Diagnostics

Nhìn sang cửa sổ bên phải bạn sẽ thấy Disk Diagnostics: Configure execution level, kích đúp vào nó.

Chọn Disabled và OK để lưu.

8. Chống phân mảnh ổ cứng:

Hiện nay có rất nhiều phần mềm để chống phân mảnh ổ cứng nhưng trong bài này mình sẽ sử dụng công cụ của Windows.

Mở This PC. Sau đó bạn nhấp vào một phân vùng bất kỳ, rồi chọn Manage -> Optimize.

Chọn phân vùng mà bạn muốn chống phân mảnh (nên chọn ổ cài ổ chứa HDH trước) rồi nhấn vào Optimize để tiến hành chống phân mảnh và tối ưu hóa phân vùng.

Ngoài ra, các bạn có thể sử dụng phần mềm bên thứ 3 như Smart Defrag 3, ưu điểm của phần mềm này là dễ sử dụng, hỗ trợ ngôn ngữ tiếng việt và hoàn toàn Miễn phí, các bạn có thể tải về và sử dụng tại:

9. Sử dụng các phần mềm dọn rác và sửa lỗi Registry:

Mở This PC, sau đó bạn nhấp vào một phân vùng mà bạn cài hệ điều hành (thường là ổ C). Chuột phải > Properties > Disk Cleanup.

Nếu muốn nhanh hơn thì các bạn có thể dùng phần mềm CCleaner, các bạn tải tại đây:

10. Gỡ các phần mềm không cần thiết, tắt các phần mềm không cần dùng lúc Windows khởi động:

- Để gỡ các phần mềm không cần thiết các bạn có thể dùng chức năng có sẵn của Windows hoặc phần mềm bên thứ 3 như Revo Uninstaller, CCleaner,...

​- Còn tắt các phần mềm, các bạn có thể sử dụng công cụ Startup ở thanh Task Manager, rồi Disable phần mềm mà bạn thấy không cần thiết (lưu ý không Disable Driver của hệ thống nhé).

​11. Windows Update:

Tải các bản vá lỗi của Mircosoft để sửa lỗi cho Windows của bạn.

Read More