线程的了解

最新推荐文章于 2022-08-28 01:10:26 发布

原创最新推荐文章于 2022-08-28 01:10:26 发布 · 277 阅读

CC 4.0 BY-SA版权

一、线程

1、线程的创建

多线程：多任务多条路径多个顺序流同时执行就是多线程。

线程优点：提高效率，同时执行

缺点：复杂

多线程的创建方式：

继承Thread类，重写run()方法，run方法中定义多线程的线程体

实现Runnable接口，重写run（）方法（推荐使用）

避免单继承的局限性

实现资源共享

实现Callable接口，重写call方法

ublic class ThreadTest extends Thread {
    @Override
    public void run() {
        super.run();
        for(int i=0;i<10;i++) {
            System.out.println("v");
            try {
                Thread.sleep(3);//线程睡眠指定时间
            } catch (InterruptedException e) {
                // TODO Auto-generated catch block
                e.printStackTrace();
            }
        }
    }
    public static void main(String[] args) {
        ThreadTest thread = new ThreadTest();
        thread.start();//开启多线程
        for(int i=0;i<10;i++) {
            System.out.println("a");
            try {
                Thread.sleep(3);
            } catch (InterruptedException e) {
                // TODO Auto-generated catch block
                e.printStackTrace();
            }
        }
    }
}

2、线程状态

新生状态：new 创建一个线程的时候

就绪状态:start(),线程会进入就绪队列，等待CPU的调度

运行状态：CPU调用分配时间片给线程，线程就会运行

阻塞状态：sleep()....

终止状态：线程结束了

一个线程一旦进入阻塞状态，阻塞解除之后，不会马上恢复运行，会恢复到就绪状态,等待CPU的调度；

一个线程一旦进入终止状态，再也不会恢复；

1.线程如何进入就绪状态：

start()

阻塞状态接除

线程切换，被切换的线程会恢复就绪状态

yield() 礼让线程

2.线程进入阻塞状态的方式

sleep()

wait()

jojin

3.控制一个线程终止

stop()

通过表示判断

正常执行结束

sleep():线程睡眠，模拟网络延迟，让出CPU的资源，不会让出对象的锁（抱着资源睡觉），指定休息多少毫秒；

yield()：礼让线程，让出CPU的资源，恢复到就绪状态

join():插队线程

getState():获取某个线程的状态

线程优先级：提高先执行的概率（1~10优先级依次变大，默认为5）

setPriority(int newPriority)：改变线程的优先级

getPriority():返回线程的优先级

public class StateTest2 implements Runnable {
    public static void main(String[] args) {
        StateTest2 sta = new StateTest2();
        new Thread(sta,"B").start();;
    }
    @Override
    public void run() {
        while(true) {
            Thread thread = new Thread(()->{
                System.out.println("插队了。。。");
                try {
                    Thread.sleep(10);
                } catch (InterruptedException e) {
                    // TODO Auto-generated catch block
                    e.printStackTrace();
                }
            });
            thread.start();
            try {
                thread.join();
            } catch (InterruptedException e) {
                // TODO Auto-generated catch block
                e.printStackTrace();
            }
            System.out.println(Thread.currentThread().getName()+"开始执行");
            thread.yield();
            System.out.println(Thread.currentThread().getName()+"结束执行");
        }
    }
    
}

3、线程安全

多线程同时操作同一份资源才可能会出现线程不安全问题，需要控制安全

同步锁：synchronized

同步方法：在方法上使用synchronized修饰

成员方法，相当于锁this,代码范围为方法

静态方法，相当于锁类（类的class对象），代码范围为方法

同步块：synchronized(锁的内容){同步的代码范围}

锁内容：this、类.class、资源（成员变量）

锁范围: {}中代码范围

注意：

锁范围太大，效率低

锁范围太小，效率高

锁不变的内容

public class SynchronizedTest implements Runnable{
    Ticket ticket=new Ticket();
    public static void main(String[] args) {
        SynchronizedTest s=new SynchronizedTest();
        Thread t1=new Thread(s,"A");
        Thread t2=new Thread(s,"B");
        Thread t3=new Thread(s,"C");
        t1.start();
        t2.start();
        t3.start();
    }
    @Override
    public void run() {
        while(true) {
//          synchronized(SynchronizedTest.class) {
//          synchronized(this) {
            synchronized(ticket) {
                if(ticket.num<=0){
                    break;
                }
                try {
                    Thread.sleep(50);
                } catch (InterruptedException e) {
                    // TODO Auto-generated catch block
                    e.printStackTrace();
                }
                System.out.println(Thread.currentThread().getName()+"买了第"+ticket.num--+"张票");
            }
        }
    }
}
class Ticket{
    int num=100;
}

4、线程通信

生产者消费者模式

wait():等待，进入这个对象的等待池中进行等待，等待被唤醒wait会让出CPU的资源，并进行释放对象的锁

notify():唤醒，notifyAll()，唤醒对象等待池中的线程，处于可运行的状态，但是需要满足同步要求并被CPU调度才能执行

要求:使用在一个同步环境下，同步一个相同的对象才行

public class StreetTest {
    public static void main(String[] args) {
        Street street = new Street();
        new Thread(new Person(street)).start();
        new Thread(new Car(street)).start();
    }
}
class Street{
    boolean light=true;//灯亮
    public synchronized void prson() {
        while(true) {
            if(light==false){
                try {
                    this.wait();
                } catch (InterruptedException e) {
                    // TODO Auto-generated catch block
                    e.printStackTrace();
                }
            }else {
                try {
                    Thread.sleep(10);
                } catch (InterruptedException e) {
                    // TODO Auto-generated catch block
                    e.printStackTrace();
                }
                light=false;
                System.out.println("person.....");
                this.notify();
            }
        }
    }
    public synchronized void car() {
        while(true) {
            if(light==true){
                try {
                    this.wait();
                } catch (InterruptedException e) {
                    // TODO Auto-generated catch block
                    e.printStackTrace();
                }
            }else {
                try {
                    Thread.sleep(10);
                } catch (InterruptedException e) {
                    // TODO Auto-generated catch block
                    e.printStackTrace();
                }
                light=true;
                System.out.println("car.....");
                this.notify();
            }
        }
    }
}
class Person implements Runnable{
    Street street;
    public Person(Street street) {
        super();
        this.street = street;
    }
    @Override
    public void run() {
        // TODO Auto-generated method stub
        street.prson();
    }
}
class Car implements Runnable{
    Street street;
    
    public Car(Street street) {
        this.street = street;
    }

    @Override
    public void run() {
        // TODO Auto-generated method stub
        street.car();
    }
}

5、网络安全

IP:定位网络上的节点

ip分类：ipv4 32位 ipv6 128位

特殊ip:

非注册ip:供组织内部使用(192.168.0.0~192.168.255.255)

本地ip：127.0.0.1

端口：区分软件 InetSocketAddress（0~65535之间的整数,2个字节）

自定义端口号推荐使用8000以上，统一协议下端口号不能冲突8000以内的预留端口号；（80：http、8080：tomcat、3306：mysql、1521：oracle）

url:统一资源定位符

传输层协议:

标准,规范,协议

udp : 非面向连接协议简单,开销小,不安全大小有限制

tcp : 基于连接 3次握手协议复杂,开销大,效率低安全大小没有限制

public static void main(String[] args) throws UnknownHostException {
        //static InetAddress getLocalHost() 返回本地主机的地址。  
        InetAddress in1=InetAddress.getLocalHost();
        System.out.println(in1);  //AB-201905250842/192.168.3.105
        
        //static InetAddress getByName(String host) 决定了IP地址的主机,主机的名字。 
        InetAddress in2=InetAddress.getByName("www.shsxt.com");
        System.out.println(in2);
        
        //InetSocketAddress(String hostname, int port)创建一个套接字地址的主机名和端口号。 
        InetSocketAddress in3=new InetSocketAddress("localhost",8888);
        System.out.println(in3);
        System.out.println(in3.getPort());
        System.out.println(in3.getAddress());
        System.out.println(in3.getHostName());
    }