Java多线程初探

package Network_Experience;

import javax.swing.*;
import java.util.concurrent.locks.ReentrantLock;

//多线程示例代码
public class NET {
    public static void main(String[] args) {
        //线程示例化
        //1.继承Thread类，做一个线程子类（自定义的线程类）
        MyThread mt = new MyThread();

        //注意：
        //需要调用start方法使线程启动
        //start方法会开启一个新的线程，来执行run中的逻辑
        mt.start();

        //2.通过Runnable接口
        Runnable r = new Runnable() {
            @Override
            public void run() {
                for(int i=0;i<10;i++){
                    System.out.println("线程2中的逻辑："+i);
                }
            }
        };
        /**通过Lambda表达式也行
         * Runnable r1 = （）->{
         *      public void run() {
         *                 for(int i=0;i<10;i++){
         *                     System.out.println("线程2中的逻辑："+i);
         *                 }
         *             }
         * };
         */
        Thread t2 = new Thread(r);
        t2.start();
        System.out.println("主线程中的逻辑执行结束了");
    }
}
class MyThread extends Thread{
    /**
     * 需要重写run方法
     * 将需要并发执行的任务写到run方法中
     */
    public void run(){
        for(int i=0;i<10;i++){
            System.out.println("子线程中的逻辑："+i);
        }
    }
}





class ThreadMethod{
    public static void main(String[] args) {
        //线程的命名
        //1.实例化一个线程对象
        Thread t = new Thread("Custom");
        t.setName("Custom");//两种方法都行
        //与其在Thread的构造参数中单单提供name，Thread(Runnable r,String name)更加常用
        //2.通过Thread子类的重写构造方法进行命名
        MyThread2 mt2 = new MyThread2("Custom");

        //System.out.println(t.getName());
        //System.out.println(mt2.getName());

        //threadSleep();
        //threadPriority();
        //threadYield();

    }
    private static void  threadSleep(){
        MyThread2 t2 = new MyThread2();
        t2.start();
    }
    private static void threadPriority(){
        //设置线程的优先级，只是修改此线程可以抢到CPU时间片的概率
        //并不是优先级高的线程一定能抢到CPU时间片
        //优先级的设置，是一个[0,10]的整数，默认为5
        Runnable r =()->{
            for(int i=0;i<100;i++){
                System.out.println(Thread.currentThread().getName()+":"+i);
            }
        };
        Thread t1 = new Thread(r,"T1");
        Thread t2 = new Thread(r,"T2");

        //设置优先级（必须要放置在start之前）
        t1.setPriority(10);
        t2.setPriority(1);

        t1.start();
        t2.start();

    }
    private static void threadYield(){
        //线程的礼让：让当前的运行态的线程释放自己的CPU资源，从运行态返回就绪态
        Runnable r = new Runnable() {
            @Override
            public void run() {
                for(int i=0;i<10;i++){
                    System.out.println(Thread.currentThread().getName()+" : "+i);
                    if(i==5){
                        Thread.yield();
                    }

                }
            }
        };
        Thread y1 = new Thread(r,"Thread-1");
        Thread y2 = new Thread(r,"Thread-2");

        y1.start();
        y2.start();
    }
}
class MyThread2 extends Thread{
    MyThread2(){};
    MyThread2(String name){
        super(name);
        //this.setName(name);也可
    }
    public void run(){
        for(int i=0;i<10;i++){
            System.out.println(i);
            //线程休眠
            //1.参数：毫秒为单位的时间差,注意捕获异常
            try{
                Thread.sleep(1000);
            }catch (InterruptedException e){
                e.printStackTrace();
            }
        }
    }
}




class SourceConflict{//临界资源问题：由于多个线程争抢同一片资源造成的问题
    public static void main(String[] args) {
        Runnable r =()->{
           /** while(TicketCenter.restCount > 0){
                System.out.println(Thread.currentThread().getName()+"卖出一张票，剩余"+ --TicketCenter.restCount+"张");
                //在输出语句的时刻有另外的线程争抢资源，导致输出语句滞后
            }*/
           //解决办法：加上对象锁,即synchronized (""),在一个线程夺得资源后其他线程夺取资源也得等这个线程执行完语句
           //或者加上类锁,即synchronize(SynchronizedDemo.class)也可
           //需要保证一点：所有线程看到的锁都是同一把锁才有效
            while(TicketCenter.restCount>0){
                synchronized (""){
                    if(TicketCenter.restCount<=0){
                        return;
                    }
                    System.out.println(Thread.currentThread().getName()+"卖出一张票，剩余"+ --TicketCenter.restCount+"张");
                }
            }
        };
        Thread t1 = new Thread(r,"Thread-1");
        Thread t2 = new Thread(r,"Thread-2");
        Thread t3 = new Thread(r,"Thread-3");
        Thread t4 = new Thread(r,"Thread-4");

        t1.start();
        t2.start();
        t3.start();
        t4.start();
    }
}
class TicketCenter{
   public static int restCount = 100;
}


class SynchronizedFunction{//同步方法
    public static void main(String[] args) {
        Runnable r =()->{
            while(TicketCenter.restCount>0){
                soldTicket();//这样与前一个类的实现等效，将同步代码段写在一个方法中
            }
        };
        Thread t1 = new Thread(r,"Thread-1");
        Thread t2 = new Thread(r,"Thread-2");
        Thread t3 = new Thread(r,"Thread-3");
        Thread t4 = new Thread(r,"Thread-4");

        t1.start();
        t2.start();
        t3.start();
        t4.start();
    }

    /**
     * 同步的方法
     * 静态方法：类锁 当前类.class
     * 非静态方法:同步锁 this
     */
    private synchronized static void soldTicket(){
            if(TicketCenter.restCount<=0){
                return;
            }
            System.out.println(Thread.currentThread().getName()+"卖出一张票，剩余"+ --TicketCenter.restCount+"张");
    }
}

class LockExample{
    public static void main(String[] args) {

        //显式锁，实例化一个锁对象,效果和同步化代码一致
        ReentrantLock lock = new ReentrantLock();

        Runnable r =()->{
            while(TicketCenter.restCount>0){
                    lock.lock();//上锁
                    if(TicketCenter.restCount<=0){
                        return;
                    }
                    System.out.println(Thread.currentThread().getName()+"卖出一张票，剩余"+ --TicketCenter.restCount+"张");
                    lock.unlock();//解锁
                }
        };
        Thread t1 = new Thread(r,"Thread-1");
        Thread t2 = new Thread(r,"Thread-2");
        Thread t3 = new Thread(r,"Thread-3");
        Thread t4 = new Thread(r,"Thread-4");

        t1.start();
        t2.start();
        t3.start();
        t4.start();
    }
}

class DeadLock{
    //死锁示例：多个线程彼此持有对方需要的锁对象，但都不释放自己的锁
    //解决办法：wait/notify
    //wait:Object类中的方法，使当前线程释放自己的锁标记并让出CPU资源，当前线程进入等待队列
    //notify:Object类中的方法，唤醒等待队列中的一个线程并使此线程进入锁池
    //notifyAll:Object类中的方法，唤醒等待队列中的所有等待这个锁的线程并使它们进入锁池，如"a".notifyAll();释放所有等待"a"的线程
    public static void main(String[] args) {
        Runnable r1 = ()->{
            synchronized ("A"){
                System.out.println("A线程持有A锁并等待B锁");

                //A线程释放已有的A锁并进入等待队列
                try {
                    "A".wait();//如果"C".wait();会异常
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }

                synchronized ("B"){
                    System.out.println("A线程同时持有A和B两把锁");
                }
            }
        };
        Runnable r2 = ()->{
            synchronized ("B"){
                System.out.println("B线程持有B锁并等待A锁");
                synchronized ("A"){
                    System.out.println("B线程同时持有B和A两把锁");
                    "A".notify();
                }
            }
        };
        Thread t1 = new Thread(r1);
        Thread t2 = new Thread(r2);

        t1.start();
        t2.start();
    }
}

class SingletonTest{//单例在多线程中的问题
    public static void main(String[] args) {
        Runnable runnable = ()->{
            Boss.getBoss();
        };
        for(int i=0;i<100;i++){
            new Thread(runnable).start();
        }
    }
}
class Boss{//懒汉式单例：只有当对象被检测到没有实例化时才调用方法进行实例化
    private Boss(){
        System.out.println("一个Boss对象被实例化了");
    }
    private static Boss instance = null;
    public static Boss getBoss(){
        synchronized (""){//通过同步锁可以解决单例在多线程中出现的问题
        if(instance==null){
            instance = new Boss();
        }}
        return instance;
    }
}