新手初學(xué)Java網(wǎng)絡(luò)編程

更新時間：2021年07月07日 14:38:19 作者：頂風(fēng)少年

網(wǎng)絡(luò)編程是指編寫運(yùn)行在多個設(shè)備（計算機(jī)）的程序，這些設(shè)備都通過網(wǎng)絡(luò)連接起來。本文介紹了一些網(wǎng)絡(luò)編程基礎(chǔ)的概念，并用Java來實(shí)現(xiàn)TCP和UDP的Socket的編程，來讓讀者更好的了解其原理

運(yùn)行線程

創(chuàng)建Thread的子類

public class ThreadChild extends Thread {
    @Override
    public void run() {
        while (true) {
            System.out.println("run");
        }
    }
}

public class Test {
    public static void main(String[] args) throws Exception {
        ThreadChild t = new ThreadChild();
        t.start();
    }
}

創(chuàng)建Thread傳入Runnable接口實(shí)現(xiàn)類

public class RunnableImpl implements Runnable {
    @Override
    public void run() {
        while (true) {
            System.out.println("run");
        }
    }
}

public class Test {
    public static void main(String[] args) throws Exception {
        Thread t = new Thread(new RunnableImpl());
        t.start();
    }
}

回調(diào)

ExecutorService線程池的Submit()可接收Runnable或者Callable.Callable執(zhí)行結(jié)束后有返回值,Runnable執(zhí)行結(jié)束后沒有返回值.可以通過submit的返回對象Future的get方法獲取返回返回值,需要注意的是get方法是一個阻塞方法.若線程沒有執(zhí)行完畢,則會阻塞get()直到線程執(zhí)行結(jié)束后返回數(shù)據(jù).

public static void main(String[] args) throws Exception {
        ExecutorService executorService = Executors.newFixedThreadPool(10);
        Future<Integer> future = executorService.submit(() -> {
            TimeUnit.SECONDS.sleep( 3);
            return 1;
        });
        Future<?> future2 = executorService.submit(() -> {
        });
        Future<String> future3 = executorService.submit(() -> {
        }, "aaa");
        System.out.println(future.get());
        System.out.println(future2.get());
        System.out.println(future3.get());
    }

同步方法

synchronized關(guān)鍵字和方法組合使用后，該方法是一個同步方法。同步方法都有一個隱試的鎖，多個線程同時執(zhí)行該方法時，只能順序執(zhí)行，未強(qiáng)到鎖的線程處于阻塞狀態(tài)。另外靜態(tài)方法和非靜態(tài)方法使用的是不同的鎖，非靜態(tài)方法的鎖是對象鎖，若兩個線程通過兩個該類的對象調(diào)用那么互不影響。靜態(tài)方法是類鎖，即本類的Class對象。同步方法無法指定鎖資源，要么是this鎖，要么是Class鎖。

public class Test {
    public static void main(String[] args) throws Exception {
        Test test = new Test();
        Thread t1 = new Thread(()->{
            test.synFunction();
        });
        Thread t2 = new Thread(()->{
            test.synFunction();
        });
        t1.start();
        t2.start();
    }
    public synchronized void synFunction(){
        try {
            System.out.println("-------------");
            TimeUnit.SECONDS.sleep(3);
        }catch (Exception e) {}        
    }
}

public class Test {
    public static void main(String[] args) throws Exception {
        Thread t1 = new Thread(()->{
            Test.synFunction();
        });
        Thread t2 = new Thread(()->{
            Test.synFunction();
        });
        t1.start();
        t2.start();
    }
    public static synchronized void synFunction(){
        try {
            System.out.println("-------------");
            TimeUnit.SECONDS.sleep(3);
        }catch (Exception e) {}        
    }
}

同步塊

同步代碼塊可以指定鎖對象，非靜態(tài)方法可以指定任意的對象鎖，或者任意的類鎖。但靜態(tài)方法只能使用任意的類鎖。

public class Test {
    public static void main(String[] args) throws Exception {
        Test lock = new Test();
        Thread t1 = new Thread(() -> {
            lock.synFunction();
        });
        Thread t2 = new Thread(() -> {
            lock.synFunction();
        });
        t1.start();
        t2.start();
    }
    public void synFunction() {
        synchronized (this) {//對象鎖
            try {
                System.out.println("-------------");
                TimeUnit.SECONDS.sleep(3);
            } catch (Exception e) {
            }
        }
    }
}

public class Test {
    public static void main(String[] args) throws Exception {
        Test lock1 = new Test();
        Test lock2 = new Test();
        Thread t1 = new Thread(() -> {
            lock1.synFunction(lock1);
        });
        Thread t2 = new Thread(() -> {
            lock2.synFunction(lock2);
        });
        t1.start();
        t2.start();
    }
    public void synFunction(Object lock) {
        synchronized (lock) {//對象鎖
            try {
                System.out.println("-------------");
                TimeUnit.SECONDS.sleep(3);
            } catch (Exception e) {
            }
        }
    }
}

public class Test {
    public static void main(String[] args) throws Exception {
        Test lock1 = new Test();
        Test lock2 = new Test();
        Thread t1 = new Thread(() -> {
            lock1.synFunction();
        });
        Thread t2 = new Thread(() -> {
            lock2.synFunction();
        });
        t1.start();
        t2.start();
    }
    public void synFunction() {
        synchronized (Test.class) {//類鎖
            try {
                System.out.println("-------------");
                TimeUnit.SECONDS.sleep(3);
            } catch (Exception e) {
            }
        }
    }
}

public class Test {
    public static void main(String[] args) throws Exception {
        Thread t1 = new Thread(() -> {
            Test.synFunction();
        });
        Thread t2 = new Thread(() -> {
            Test.synFunction();
        });
        t1.start();
        t2.start();
    }
    public static void synFunction() {
        synchronized (Object.class) {//類鎖
            try {
                System.out.println("-------------");
                TimeUnit.SECONDS.sleep(3);
            } catch (Exception e) {
            }
        }
    }
}

死鎖

當(dāng)多個線程競爭鎖時，可能會導(dǎo)致死鎖。一個線程由于沒有得到一個鎖而阻塞它也不會釋放已經(jīng)獲取的鎖。方法1獲取鎖的順序是Test.class,Object.class。方法2獲取鎖的順序是Object.class，Test.class。程序會陷入死鎖。

public class Test {
    public static void main(String[] args) throws Exception {
        Thread t1 = new Thread(() -> {
            Test.synFunction1();
        });
        Thread t2 = new Thread(() -> {
             Test.synFunction2();
        });
        t1.start();
        t2.start();
    }
    public static void synFunction1() {
        synchronized (Test.class) {// 類鎖
            try {
                System.out.println("synFunction1-------------AAAAAAAAAAAAA");
                synchronized (Object.class) {// 類鎖
                    try {
                        System.out.println("synFunction1-------------bbbbbbbbbbbbb");
                    } catch (Exception e) {
                    }
                }
            } catch (Exception e) {
            }
        }    
    }
    public static void synFunction2() {
        synchronized (Object.class) {// 類鎖
            try {
                System.out.println("synFunction2-------------AAAAAAAAAAAAA");
            } catch (Exception e) {
            }
            synchronized (Test.class) {// 類鎖
                try {
                    System.out.println("synFunction2-------------bbbbbbbbbbbbb");
                } catch (Exception e) {
                }
            }
        }
    }
}

優(yōu)先級

不是所有線程創(chuàng)建時都是均等的，每個線程都有一個優(yōu)先級，指定從0-10的整數(shù)。當(dāng)多個線程運(yùn)行時，虛擬機(jī)通常只運(yùn)行最高優(yōu)先級的線程，但這并不是一個嚴(yán)格的規(guī)則。在Java中10是最高優(yōu)先級，0是最低優(yōu)先級。默認(rèn)優(yōu)先級為5.并不是所有操作系統(tǒng)都支持這11個優(yōu)先級。例如Windows只有7個優(yōu)先級。優(yōu)先級（1，2）（3，4）（6，7）（8，9）會做同樣的處理。

public class Test {
    public static void main(String[] args) throws Exception {
        Thread t1 = new Thread(() -> {
            Test.synFunction("aaaaaaaaaaa");
        });
        Thread t2 = new Thread(() -> {
             Test.synFunction("bbbbbbbbbb");
        });
        t2.setPriority(9);
        t1.setPriority(1);
        t1.start();
        t2.start();
    }
    public static void synFunction(String name) {
        System.out.println(name+"--------------");
    }
}

暫停

為了能讓其他線程有機(jī)會運(yùn)行，一個線程有8中方式可以暫?；蛘咧甘舅鼫?zhǔn)備暫停。

可以對IO阻塞

要讓網(wǎng)絡(luò)程序中的線程自動放棄CPU控制權(quán)，最常見的方式是IO阻塞。由于CPU比網(wǎng)絡(luò)和磁盤快的多，網(wǎng)絡(luò)程序經(jīng)常會在等待數(shù)據(jù)從網(wǎng)絡(luò)到達(dá)或向網(wǎng)絡(luò)發(fā)送數(shù)據(jù)時阻塞。即使只阻塞幾毫秒，這一點(diǎn)時間也足夠其他線程用來完成重要的任務(wù)。

可以對同步對象阻塞

線程在進(jìn)入一個同步方法或代碼塊時也會阻塞。如果這個線程沒有所同步對象的鎖，而其他線程擁有這個鎖，這個線程就會暫停，直到鎖被釋放為止。如果這個鎖永遠(yuǎn)不會釋放，那么這個線程會永久停止。

可以放棄

調(diào)用Thread.yield()靜態(tài)方法可以做到顯試的放棄線程控制權(quán)，這將通知虛擬機(jī)，可以優(yōu)先執(zhí)行其他線程。放棄并不會釋放這個線程擁有的鎖，因此在理想情況下被放棄的線程不要做任何的同步。如果等待運(yùn)行的其他線程都是因?yàn)檫@個線程所擁有的同步資源而阻塞，那么這些線程將不能運(yùn)行。實(shí)際上，控制權(quán)將回到唯一可以運(yùn)行的線程，即剛剛放棄的這個線程，這很大程度上失去了放棄的意義。

public class Test {
    public static void main(String[] args) throws Exception {
        Thread t1 = new Thread(() -> {
            Test.synFunction("aaaaaaaaaaa");
        });
        Thread t2 = new Thread(() -> {
            Test.synFunction2("bbbbbbbbbb");
        });
        t1.start();
        t2.start();
    }
    public static void synFunction(String name) {
        for (int i = 0;; i++) {
            Thread.yield();
            System.out.println(name + "--------------" + i);
        }
    }
    public static void synFunction2(String name) {
        for (int i = 0;; i++)
            System.out.println(name + "--------------"+i);
    }
}

可以休眠

休眠是更有利的放棄方式。放棄只是表示線程愿意暫停，讓其他有相同優(yōu)先級的線程有機(jī)會運(yùn)行，而進(jìn)入休眠的線程有所不同，不管有沒有其他線程準(zhǔn)備運(yùn)行，休眠線程都會暫停。這樣一來，不只是其他有相同優(yōu)先級的線程會得到機(jī)會，還會給較低優(yōu)先級的線程運(yùn)行機(jī)會。不過進(jìn)入休眠的線程仍然擁有它已經(jīng)獲得得所有鎖。因此其他需要相同鎖得線程依然會阻塞，要避免在同步方法或塊內(nèi)讓線程休眠。

public class Test {
    public static void main(String[] args) throws Exception {
        Thread t1 = new Thread(() -> {
            Test.synFunction("aaaaaaaaaaa");
        });
        Thread t2 = new Thread(() -> {
            Test.synFunction2("bbbbbbbbbb");
        });
        t1.start();
        t2.start();
    }
    public synchronized static void synFunction(String name) {
        try {
            System.out.println(name);
            Thread.sleep(1000 * 10);
        } catch (Exception e) {
        }
    }
    public synchronized static void synFunction2(String name) {
        System.out.println(name);
    }
}

package com.datang.bingxiang.demo;
import java.util.concurrent.TimeUnit;
public class Test {
    public static void main(String[] args) throws Exception {
        Thread t1 = new Thread(() -> {
            Test.synFunction("aaaaaaaaaaa");
        });
        Thread t2 = new Thread(() -> {
            Test.synFunction2("bbbbbbbbbb");
        });
        t1.start();
        t2.start();
    }
    public synchronized static void synFunction(String name) {
        try {
            System.out.println(name);
            Thread.sleep(1000 * 3, 999999);//3000毫秒+999999毫秒（第二個參數(shù)不能超過999999，也就是不能超過1毫秒）
        } catch (Exception e) {
            System.out.println(e);
        }
    }
    public synchronized static void synFunction2(String name) {
        System.out.println(name);
    }
}

可以連接另一個線程

連接線程(既調(diào)用join()方法得線程A)等待被連接的線程(join()方法所屬的線程對象B)執(zhí)行完畢后才會執(zhí)行。在A線程調(diào)用B線程的join()A線程會等待B線程執(zhí)行結(jié)束后才會繼續(xù)執(zhí)行。要注意的是A線程并不會釋放已經(jīng)獲取的鎖資源。

public class Test {
    public static void main(String[] args) throws Exception {
        Thread t2 = new Thread(() -> {
            Test.synFunction2("bbbbbbbbbb");
        });
        Thread t1 = new Thread(() -> {
            Test.synFunction("aaaaaaaaaaa",t2);
        });
        
        t1.start();
        t2.start();
    }
    public  static void synFunction(String name,Thread t) {
        try {
            t.join();
            //t.join(1000);
            //t.join(1000,999999);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        for (int i = 0; i < 5; i++) {
            System.out.println(name);
        }
    }
    public  static void synFunction2(String name) {
        try {
            Thread.sleep(1000*3);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        for (int i = 0; i < 5; i++) {
            System.out.println(name);
        }
    }
}

可以等待一個對象

線程可以等待一個它鎖定的對象.在等待時,它會釋放這個對象的鎖并暫停,直到它得到其他線程的通知.另一個線程以某種方式修改這個對象,通知等待對象的線程,然后繼續(xù)執(zhí)行.等待會暫停執(zhí)行,直到一個對象或資源到達(dá)某種狀態(tài).實(shí)際上,要等待某個特定的對象,希望暫停的線程首先必須使用synchronized獲得這個對象的鎖,然后調(diào)用這個對象的三個重載wait()方法之一.

public class Demo {
    public static void main(String[] args) throws Exception {
        Demo d = new Demo();
        Thread t1 = new Thread(() -> {
            d.a();
        });
        Thread t2 = new Thread(() -> {
            d.b();
        });
        t1.start();
        t2.start();
    }
    boolean flag = true;
    public synchronized void a() {
        try {
            while (true) {
                if (flag) {
                    System.out.println("執(zhí)行AAAAAAAAAAA");
                    flag = false;
                } else {
                    wait();//等待,不限制等待時間
                    //wait(1000);//等待指定的時間,沒有被notify喚醒也可以自己退出等待
                    //wait(1000,999999);//毫秒+納秒的等待時間
                }
                notify();
            }
        } catch (Exception e) {
        }
    }
    public synchronized void b() {
        try {
            while (true) {
                if (!flag) {
                    System.out.println("執(zhí)行BBBBBBBBBBB");
                    flag = true;
                } else {
                    wait();
                }
                notify();
            }
        } catch (Exception e) {
        }
    }
}

可以結(jié)束

線程要以合理的方式放棄CPU控制權(quán),一種方式是結(jié)束.當(dāng)run()方法返回線程時,線程將撤銷,其他線程可以接管CPU.在網(wǎng)絡(luò)應(yīng)用程序中,包裝一個阻塞操作的線程往往會這么做,例如線程從服務(wù)器下載一個文件,這樣應(yīng)用程序的其他部分就不會被阻塞.另一方面,如果run()方法太簡單,總是很快結(jié)束,而不會紫色,那就存在一個很實(shí)際的問題:到底有沒有必要生成一個線程.虛擬機(jī)在建立和撤銷線程時會有很大的開銷.如果線程會在極端的時間內(nèi)結(jié)束,那么使用一次簡單的方法調(diào)用而不是單獨(dú)的線程可能會結(jié)束的更快.