介紹
程式(program)是為完成特定任務、用某種語言編寫的一組指令的集合。即指一段靜態的程式碼，靜態物件。
程式(process)是程式的一次執行過程，或是正在執行的一個程式。是一個動態的過程:有它自身的產生、存在和消亡的過程。——生命週期
>如:執行中的QQ，執行中的MP3播放器
>程式是靜態的，程式是動態的
>程式作為資源分配的單位，系統在執行時會為每個程式分配不同的記憶體區域
執行緒(thread)，程式可進一步細化為執行緒，是一個程式內部的一條執行路徑。若一個程式同一時間並行執行多個執行緒，就是支援多執行緒的執行緒作為排程和執行的單位，每個執行緒擁有獨立的執行棧和程式計數器(pc)，執行緒切換的開銷小；
一個程式中的多個執行緒共享相同的記憶體單元/記憶體地址空間→它們從同一堆中分配物件，可以訪問相同的變數和物件。這就使得執行緒間通訊更簡便、高效。但多個執行緒操作共享的系統資源可能就會帶來安全的隱患。
為什麼需要多執行緒
眾所周知，CPU、記憶體、I/O 裝置的速度是有極大差異的，為了合理利用 CPU 的高效能，平衡這三者的速度差異，計算機體系結構、作業系統、編譯程式都做出了貢獻。
執行緒狀態轉換
新建(New)
建立後尚未啟動。
就緒(Runnable)
可能正在執行，也可能正在等待 CPU 時間片。
包含了作業系統執行緒狀態中的 Running 和 Ready。
阻塞(Blocking)
等待獲取一個排它鎖，如果其執行緒釋放了鎖就會結束此狀態。
無限期等待(Waiting)
等待其它執行緒顯式地喚醒，否則不會被分配 CPU 時間片。
限期等待(Timed Waiting)
無需等待其它執行緒顯式地喚醒，在一定時間之後會被系統自動喚醒。
呼叫 Thread.sleep() 方法使執行緒進入限期等待狀態時，常常用“使一個執行緒睡眠”進行描述。
呼叫 Object.wait() 方法使執行緒進入限期等待或者無限期等待時，常常用“掛起一個執行緒”進行描述。
睡眠和掛起是用來描述行為，而阻塞和等待用來描述狀態。
阻塞和等待的區別在於，阻塞是被動的，它是在等待獲取一個排它鎖。而等待是主動的，通過呼叫 Thread.sleep() 和 Object.wait() 等方法進入。
死亡(Terminated)
可以是執行緒結束任務之後自己結束，或者產生了異常而結束。
執行緒使用方式
有三種使用執行緒的方法:
- 實現 Runnable 介面；
- 實現 Callable 介面；
- 繼承 Thread 類。
實現 Runnable 和 Callable 介面的類只能當做一個可以線上程中執行的任務，不是真正意義上的執行緒，因此最後還需要通過 Thread 來呼叫。可以說任務是通過執行緒驅動從而執行的。
繼承 Thread 類
public class ThreadTest {
/**
* 多執行緒的建立，
* 方式一：
* 1.繼承與Thread類
* 2.重寫Thread類的run方法->將此執行緒執行的操作宣告在run中
* 3.建立Thread類的子類
* 4.通過此物件呼叫start
*/
public static void main(String[] args) {
// 建立Thread類的子類的物件
MyThread t1 = new MyThread();
//不能通過run方法開啟執行緒，因為還會在主執行緒中執行，應該使用start方法開啟執行緒
//不能通過呼叫兩次start方法來開啟兩個子執行緒
t1.start();
//可以通過再建立一個物件來實現
for (int i=0;i<1000;i++){
if (i%2!=0){
System.out.println(i+"****");
}
}
}
}
class MyThread extends Thread{
@Override
public void run() {
for (int i=0;i<1000;i++){
if (i%2==0){
System.out.println(i);
}
}
}
}
/**
* 方式二：
* 匿名子類建立，針對只呼叫一次的執行緒
*/
public static void main(String[] args) {
MyThread1 myThread1 = new MyThread1();
myThread1.start();
MyThread2 myThread2 = new MyThread2();
myThread2.start();
//通過匿名子類實現呼叫：特點只需要呼叫一次的子執行緒
new Thread(){
@Override
public void run() {
for (int i=0;i<1000;i++){
if (i%3==0){
System.out.println(Thread.currentThread().getName()+"***"+i);
}
}
}
}.start();
}
}
class MyThread1 extends Thread{
@Override
public void run() {
for (int i=0;i<100;i++){
if (i%2!=0){
System.out.println(Thread.currentThread().getName()+"***"+i);
}
}
}
}
class MyThread2 extends Thread{
@Override
public void run() {
for (int i=0;i<100;i++){
if (i%2==0){
System.out.println(Thread.currentThread().getName()+"***"+i);
}
}
}
}
實現 Runnable 介面
package com.atguigu.juc.runnable;
/**
* 建立多執行緒方式Runnable
* 1.建立一個實現Runnable介面的類
*
* 2.實現類去實現Runnable中的抽象方法: run( )
*
* 3.建立實現類的物件
*
* 4、將此物件作為引數傳遞到Thread類的構造器中，建立Thread類的物件
*
* 5，通過Thread類的物件呼叫start()
*/
public class TestThread {
public static void main(String[] args) {
//3.建立實現類的物件
MyThread myThread = new MyThread();
//4、將此物件作為引數傳遞到Thread類的構造器中，建立Thread類的物件
Thread t1 = new Thread(myThread);
//5，通過Thread類的物件呼叫start()
t1.start();
}
}
//1.建立一個實現Runnable介面的類
class MyThread implements Runnable{
//2.實現類去實現Runnable中的抽象方法: run( )
@Override
public void run() {
for (int i=0;i<100;i++){
if (i%2==0){
System.out.println(i);
}
}
}
}
實現 Callable 介面
執行緒常見方法
package com.atguigu.juc.tset01;
/**
* 1.yield():釋放當前cpu的執行權
*
* 2.start():啟動當前執行緒;呼叫當前執行緒的run()
*
* 3.run():通常需要重寫Thread類中的此方法，將建立的執行緒要執行的操作宣告在此方法中
*
* 4.getName()∶獲取當前執行緒的名字
*
* 5.setName():設定當前執行緒的名字
*
* 6.currentThread():靜態方法，返回執行當前程式碼的執行緒
*
* 7.join():線上程a中呼叫執行緒b的join(),此時執行緒a就進入阻塞狀態，直到執行緒b完全執行完以後，執行緒a才結束阻塞狀態。
*
* 8.sleep():讓當前執行緒"睡眠”指定的毫秒。在指定的毫秒時間內，當前執行緒是阻塞狀態。
*
*/
public class MyThreatTest {
public static void main(String[] args) {
TestMyThread t1 = new TestMyThread();
t1.start();
new Thread(){
@Override
public void run(){
for (int i=0;i<100;i++){
if (i%2==0){
try {
sleep(100);
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println(Thread.currentThread().getName() + "子執行緒" + i);
yield();
}
}
}
}.start();
for (int i=0;i<100;i++){
if (i%3==0){
System.out.println(Thread.currentThread().getName() + "main方法" + i);
}
if (i==20){
try {
t1.join();
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
}
}
class TestMyThread extends Thread{
@Override
public void run(){
for (int i=0;i<100;i++){
if (i%5==0){
System.out.println(Thread.currentThread().getName() + "2222222222222子執行緒" + i);
}
}
}
}
synchronized鎖機制
- 一把鎖只能同時被一個執行緒獲取，沒有獲得鎖的執行緒只能等待；
- 每個例項都對應有自己的一把鎖(this),不同例項之間互不影響；例外：鎖物件是*.class以及synchronized修飾的是static方法的時候，所有物件公用同一把鎖
- synchronized修飾的方法，無論方法正常執行完畢還是丟擲異常，都會釋放鎖
同步程式碼---Runnable介面方式
/**
*方式一:同步程式碼塊
* synchronized(同步監視器){
* //需要被同步的程式碼
* }
* 說明:
* 1.操作共享資料的程式碼，即為需要被同步的程式碼
* 2.共享資料:多個執行緒共同操作的變數
* 3.同步監視器，俗稱:鎖。任何一個類的物件都可以作為索
* 4.在Java中，我們通過同步機制，來解決執行緒的安全問題。
* 補充:在實現Runnable介面建立多執行緒的方式中，我們可以考慮使用this充當同步監視器。
* 方式二:同步方法
* 如果操作共享資料的程式碼完整的宣告在一個方法中，我們不妨將此方法宣告同步的。
* 5.同步的方式，解決了執行緒的安全問題。---好處
* 操作同步程式碼時，只能有一個執行緒參與，其他執行緒等待。相當於是一個單執行緒的過程，效率低。
*/
public class WindowToRunnable {
public static void main(String[] args) {
Window2 window2 = new Window2();
Thread t1 = new Thread(window2);
Thread t2 = new Thread(window2);
Thread t3 = new Thread(window2);
t1.setName("視窗1");
t2.setName("視窗2");
t3.setName("視窗3");
t1.start();
t2.start();
t3.start();
}
}
class Window2 implements Runnable{
//這裡不用加static,因為呼叫的物件只有一個
private int ticket=100;
@Override
public void run() {
while (true) {
synchronized (this.getClass()){
if (ticket > 0) {
// try {
// Thread.sleep(100);
// } catch (InterruptedException e) {
// e.printStackTrace();
// }
System.out.println(Thread.currentThread().getName() + "買票,票號:" + ticket);
ticket--;
}
}
}
}
}
同步方法--Runnable介面方法
package com.atguigu.juc.bookPage;
/**
* 使用同步方法解決實現Runnable介面的執行緒安全問題
* 關於同步方法的總結:
* 1.同步方法仍然涉及到同步監視器，只是不需要我們顯式的宣告。
* 2．非靜態的同步方法，同步監視器是: this
* 靜態的同步方法，同步監視器是:當前類本身
*/
public class WindowExtSynn {
public static void main(String[] args) {
Window4 w1 = new Window4();
Window4 w2 = new Window4();
Window4 w3 = new Window4();
w1.setName("視窗1");
w2.setName("視窗2");
w3.setName("視窗3");
w1.start();
w2.start();
w3.start();
}
}
class Window4 extends Thread{
private static int ticket=100;
@Override
public void run() {
while (true){
show();
}
}
private static synchronized void show() {
if (ticket>0){
System.out.println(Thread.currentThread().getName()+":買票：票號為"+ticket);
ticket--;
}
}
}
同步方法---繼承方法
package com.atguigu.juc.bookPage;
/**
* 使用同步方法解決實現Runnable介面的執行緒安全問題
* 關於同步方法的總結:
* 1.同步方法仍然涉及到同步監視器，只是不需要我們顯式的宣告。
* 2．非靜態的同步方法，同步監視器是: this
* 靜態的同步方法，同步監視器是:當前類本身
*/
public class WindowExtSynn {
public static void main(String[] args) {
Window4 w1 = new Window4();
Window4 w2 = new Window4();
Window4 w3 = new Window4();
w1.setName("視窗1");
w2.setName("視窗2");
w3.setName("視窗3");
w1.start();
w2.start();
w3.start();
}
}
class Window4 extends Thread{
private static int ticket=100;
@Override
public void run() {
while (true){
show();
}
}
private static synchronized void show() {
if (ticket>0){
System.out.println(Thread.currentThread().getName()+":買票：票號為"+ticket);
ticket--;
}
}
}
死鎖
示例：兩個執行緒都拿到第一層鎖的key，然後都需要第二層鎖的key，但key在對方手中，而方法沒有執行完，都不可能釋放key，互相僵持。
import static java.lang.Thread.sleep;
public class TestSyn {
public static void main(String[] args) {
StringBuffer s1 = new StringBuffer();
StringBuffer s2 = new StringBuffer();
new Thread(){
@Override
public void run() {
synchronized (s1) {
s1.append("a");
s2.append("1");
try {
sleep(100);
} catch (InterruptedException e) {
e.printStackTrace();
}
synchronized (s2) {
s1.append("b");
s2.append("2");
System.out.println(s1);
System.out.println(s2);
}
}
}
}.start();
new Thread(new Runnable() {
@Override
public void run() {
synchronized (s2) {
s1.append("c");
s2.append("3");
try {
sleep(100);
} catch (InterruptedException e) {
e.printStackTrace();
}
synchronized (s1) {
s1.append("d");
s2.append("4");
System.out.println(s1);
System.out.println(s2);
}
}
}
}).start();
}
}
Lock鎖機制
import java.util.concurrent.locks.ReentrantLock;
/**
* 解決執行緒安全問題的方式三: Lock鎖--- JDK5.0新增
*
* synchronized 與Lock的異同?
* 相同:二者都可以解決執行緒安全問題
* 不同: synchronized機制在執行完相應的同步程式碼以後，自動的釋放同步監視器
* Lock需要手動的啟動同步(Lock() )，同時結束同步也需要手動的實現(unlock())
*
*/
public class LockTest {
public static void main(String[] args) {
Window6 window6 = new Window6();
Thread t1 = new Thread(window6);
Thread t2 = new Thread(window6);
Thread t3 = new Thread(window6);
t1.setName("視窗1");
t2.setName("視窗2");
t3.setName("視窗3");
t1.start();
t2.start();
t3.start();
}
}
class Window6 implements Runnable{
private int ticker=100;
private ReentrantLock lock=new ReentrantLock();
@Override
public void run() {
while (true){
lock.lock();
try {
if (ticker>0){
System.out.println(Thread.currentThread().getName()+"買票：票號："+ticker);
ticker--;
}else {
break;
}
} finally {
lock.unlock();
}
}
}
}
銀行有一個賬戶。有兩個儲戶分別向同一個賬戶存3000元，每次存1e00，存3次。每次存完列印賬戶餘額。
/**
* 銀行有一個賬戶。
* 有兩個儲戶分別向同一個賬戶存3000元，每次存1e00，存3次。每次存完列印賬戶餘額。
* 分析:
* 1.是否是多執行緒問題?是，兩個儲戶執行緒
* 2.是否有共享資料?有，賬戶（或賬戶餘額).
* 3.是否有執行緒安全問題?有
* 4.需要考慮如何解決執行緒安全問題?同步機制:有三種方式。
*/
public class AccountTest {
public static void main(String[] args) {
Account account = new Account(0);
Customer c1 = new Customer(account);
Customer c2 = new Customer(account);
c1.setName("A");
c2.setName("B");
c1.start();
c2.start();
}
}
class Account{
private double balance;
public Account(double balance) {
this.balance = balance;
}
//存錢
public synchronized void deposit(double amt){
//synchronized (this.getClass()) {
if (amt>0){
try {
Thread.sleep(100);
} catch (InterruptedException e) {
e.printStackTrace();
}
balance+=amt;
System.out.println(Thread.currentThread().getName()+"存錢成功，餘額為"+balance);
}
// }
}
}
class Customer extends Thread{
private Account acc;
public Customer(Account acc){
this.acc=acc;
}
@Override
public void run() {
for (int i=0;i<30;i++){
acc.deposit(1000);
}
}
}
A存錢成功，餘額為1000.0 B存錢成功，餘額為2000.0 B存錢成功，餘額為3000.0 B存錢成功，餘額為4000.0 A存錢成功，餘額為5000.0 A存錢成功，餘額為6000.0