JAVA基础一大堆0805线程

锁

public class DeadLockRunnable1 implements Runnable {
    private String lock1 = "abc";
    private String lock2 = "def";
    @Override
    public void run() {
        synchronized (lock1) {
            try {
                Thread.sleep(500);
                System.out.println("run1:麻溜把lock2的钥匙给我！");
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            try {
                System.out.println("run1释放lock1，lock1等待");
                lock1.wait();//释放lock1,等待被唤醒
                System.out.println("run1中lcok1被唤醒，结束等待");
            } catch (InterruptedException e) {
                // TODO Auto-generated catch block
                e.printStackTrace();
            }
            synchronized (lock2) {
                System.out.println("run1等到了lock2");
            }//lock2运行结束被释放
        }//lock1运行结束被释放
    }
}

public class DeadLockRunnable2 implements Runnable {
    private String lock1 = "abc";
    private String lock2 = "def";
    @Override
    public void run() {
        synchronized (lock2) {
            try {
                Thread.sleep(500);
                System.out.println("run2:你倒是先把lock1的钥匙给我啊！");
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            synchronized (lock1) {
                System.out.println("run2等到了lock1");
                System.out.println("run2唤醒等待的lock1");
                lock1.notify();
                try {
                    Thread.sleep(3000);
                } catch (InterruptedException e) {
                    // TODO Auto-generated catch block
                    e.printStackTrace();
                }
                System.out.println("run2运行完，lock1是同步代码块");//lock1运行结束，释放lock1
            }
        }//lock2运行结束,释放lock2
    }
}

public class DeadLockRunnableTest {

    public static void main(String[] args) {
        DeadLockRunnable1 run1=new DeadLockRunnable1();
        DeadLockRunnable2 run2=new DeadLockRunnable2();
        Thread t1=new Thread(run1);
        Thread t2=new Thread(run2);
        t1.start();
        try {
            Thread.sleep(300);
        } catch (InterruptedException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }
        t2.start();
    }
}

多线程TCP

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.net.Socket;

public class MyRead implements Runnable{
    private Socket socket;
    public MyRead(Socket socket){
        this.socket=socket;
    }
    @Override
    public void run() {
        BufferedReader br=null;
            try {
                InputStream is=socket.getInputStream();
                InputStreamReader isr=new InputStreamReader(is);
                br=new BufferedReader(isr);
                //br=new BufferedReader(new InputStreamReader(is));等于上面两句
            } catch (IOException e) {
                e.printStackTrace();
            }
            while(true){
                try {
                    String line=br.readLine();
                    System.out.println("对方说了： "+line);
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
    }
}

import java.io.BufferedWriter;
import java.io.IOException;
import java.io.OutputStream;
import java.io.OutputStreamWriter;
import java.net.Socket;
import java.util.Scanner;

public class MyWrite implements Runnable{
    private Socket socket;
    public MyWrite(Socket socket){
        this.socket=socket;
    }
    @Override
    public void run() {
        BufferedWriter bw=null;
        try {
            OutputStream os=socket.getOutputStream();
            bw=new BufferedWriter(new OutputStreamWriter(os));
            Scanner scanner=new Scanner(System.in);
            while(true){
                String words=scanner.nextLine();
                bw.write(words+"\n");
                bw.flush();
            }
        } catch (IOException e) {
            e.printStackTrace();
        }


    }

}

import java.io.IOException;
import java.net.ServerSocket;
import java.net.Socket;

public class MyServer {

    public static void main(String[] args) {
        try {
            ServerSocket server = new ServerSocket(8080);
            System.out.println("服务器启动");
            Socket socket = server.accept();
            Thread read =new Thread(new MyRead(socket));
            Thread write =new Thread(new MyWrite(socket));
            read.start();
            write.start();
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

import java.io.IOException;
import java.net.Socket;
import java.net.UnknownHostException;

public class MyClient {

    public static void main(String[] args) {
        System.out.println("客户端连接");
        try {
            Socket socket=new Socket("192.168.0.44",8080);
            Thread read =new Thread(new MyRead(socket));
            Thread write =new Thread(new MyWrite(socket));
            read.start();
            write.start();
        } catch (UnknownHostException e) {
            e.printStackTrace();
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

生产者消费者

public class Consumer implements Runnable {
    private Product pro;

    public Consumer(Product pro) {
        this.pro = pro;
    }

    @Override
    public void run() {
        while (true) {
            try {
                Thread.sleep(500);//保证每次生产者先进入
            } catch (InterruptedException e1) {
                // TODO Auto-generated catch block
                e1.printStackTrace();
            }
            synchronized (pro) {//同步代码块
                System.out.println("消费者抢到仓库");
                if(pro.getNum()!=0){
                    System.out.println("消费者消费"+pro.getNum()+"个商品");
                    try {
                        Thread.sleep(2000);
                    } catch (InterruptedException e) {
                        // TODO Auto-generated catch block
                        e.printStackTrace();
                    }
                    pro.setNum(0);
                    pro.notify();
                }
            }
        }
    }
}

public class Producer implements Runnable{
    private Product pro;
    public Producer(Product pro){
        this.pro=pro;
    }
    @Override
    public void run() {
        while(true){
            synchronized (pro) {
                System.out.println("生产者抢到仓库");
                if(pro.getNum()==0){
                    System.out.println("生产者生产1个商品");
                    try {
                        Thread.sleep(3000);
                    } catch (InterruptedException e) {
                        // TODO Auto-generated catch block
                        e.printStackTrace();
                    }
                    pro.setNum(1);
                    try {
                        pro.wait();
                    } catch (InterruptedException e) {
                        // TODO Auto-generated catch block
                        e.printStackTrace();
                    }
                }
            }
        }
    }

}

public class Product {
    private int num;

    public int getNum() {
        return num;
    }

    public void setNum(int num) {
        this.num = num;
    }
}

public class Test {

    public static void main(String[] args) {
        Product product=new Product();
//      Producer producer=new Producer(product);
        Thread producer=new Thread(new Producer(product));
        Thread consumer=new Thread(new Consumer(product));
        producer.start();
        try {
            Thread.sleep(500);
        } catch (InterruptedException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }
        consumer.start();
    }

}