Java多線程筆記
介紹
程序(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
