Java多线程篇

创建线程方式一：继承Thread类，重写run()方法，调用start()开启线程

注意：线程开启不一定立即执行，由CPU调度执行

public class TestThread1 extends Thread{
    @Override
    public void run(){
        for(int i=0;i<20;i++){
            System.out.println("我在敲代码"+i);
        }
    }

    public static void main(String[] args){
        TestThread1 testThread = new TestThread1();
        testThread.start();
        for(int i=0;i<20;i++){
            System.out.println("我在学习多线程"+i);
        }
    }
}

创建线程方式二：实现Runnable接口，重写run()方法，执行线程需要丢入Runnable接口实现类，调用start方法开启线程

public class TestThread2 implements Runnable{
    @Override
    public void run(){
        for(int i=0;i<20;i++){
            System.out.println("我在敲代码"+i);
        }
    }

    public static void main(String[] args){
        TestThread2 testThread2 = new TestThread2();
        new Thread(testThread2).start();
        for(int i=0;i<20;i++){
            System.out.println("我在学习多线程"+i);
        }
    }
}

创建线程方式三：实现Callable接口，重写call()方法 

public class TestThread3 implements Callable<Boolean>{
    @Override
    public Boolean call(){
        for(int i=0;i<20;i++){
            System.out.println("我在敲代码"+i);
        }
        return true;
    }

    public static void main(String[] args){

        //线程执行另一种方式
        FutureTask<Boolean> task=new FutureTask(new TestThread3());
        new Thread(task).start();
        // 3.创建目标对象
        TestThread3 testThread3 = new TestThread3();
        // 4.创建执行服务
        ExecutorService ser = Executors.newFixedThreadPool(1);
        // 5.提交执行
        Future<Boolean> r1 = ser.submit(testThread3);
        // 6.获取结果
        boolean res1=r1.get();
        // 7.关闭服务
        ser.shutdownNow();
        for(int i=0;i<20;i++){
            System.out.println("我在学习多线程"+i);
        }
    }
}

静态代理模式总结：真实对象和代理对象都要实现同一个接口 代理对象要代理真实角色

好处：代理对象可以做很多真实对象做不了的事情，真实对象专注做自己的事情

new Thread(()->System.out.println("我爱你")).start();
new WeddingCompany(new You()).happyMarry();

线程礼让yield

• 礼让线程让当前正在执行的线程暂停，但不阻塞
• 将线程从运行状态转为就绪状态
• 让cpu重新调度，礼让不一定成功，看CPU心情

线程插队join

• join合并线程，待此线程执行完成后，再执行其他线程，其他线程阻塞
• 可以想象成插队 

获取/改变优先级

getPriority()/setPriority(int n) 

守护线程 

• 线程分为用户线程（默认）和守护线程
• 虚拟机必须确保用户线程执行完毕
• 虚拟机不用等待守护线程执行完毕，如垃圾回收等待gc、后台记录操作日志等（用户线程执行完毕后，守护线程还会再跑一会，关闭虚拟机需要一段时间）

thread.setDaemon(true);//默认false为用户线程，设置true为守护线程

线程同步形成条件：队列+锁（引起性能问题）

sleep睡眠可以放大问题的发生性

线程安全：synchronize方法锁的是类本身，synchronize代码块锁可以是任何对象

JUC包下: CopyOnWriteArrayList线程安全

死锁：多个线程互相抱着对方需要的资源僵持着

某一个同步块同时拥有两个以上对象的锁时，就有可能发生死锁

lock锁

private final ReentrantLock lock=new ReentrantLock();
lock.lock();//加锁通常放在try代码块里
lock.unlock();//释放锁通常放在finally代码块里

使用Lock锁，jvm花费更少时间来调度线程，性能更好，并且具有更好的扩展性

优先选择顺序：Lock -> 同步代码块（已经进入了方法体，分配了相应资源）-> 同步方法（在方法体之外）