Java--多线程

2018-11-08 本文已影响47人上官轩明

多线程

线程的五个状态新建，就绪，执行，等待，销毁

新建线程需要调用start()方法才会进入就绪状态
处于就绪状态的线程并不一定立即被执行，而是听从CPU调度，即将被执行，所以被称为就绪
处于等待状态的线程不会被CPU调度

如何创建新的线程

方法一

public class TestThread extends Thread {
    //默认构造方法
    public TestThread(){}

    //传入的String参数为线程名称
    public TestThread(String name) {
        super(name);
    }
    //该方法在线程由就绪转为执行时被调用
    @Override
    public void run() {
        super.run();
        System.out.println(this.getName());
    }
}

这样我们已经声明了自己的线程类，对于不同的线程，他们的区别主要在于他们的run()方法内的业务逻辑不同，同时我们需要注意的是，我们还没有实例化对象，也就是说现在新的线程还没有被创建.

public static void main(String[] args) {
    TestThread thread1 = new TestThread("新线程");
    thread1.start();
}

只有当线程对象的start()方法被调用时，该线程才真正进入就绪状态，等待CPU调度，进入执行状态.

方法二

//实例化runnable对象
TestRunnable runnable = new TestRunnable();
//实例化Thread对象，将runnable对象作为参数
Thread thread2 = new Thread(runnable);
thread2.start();

当我们去自定义自己的Thread时候，我们只是希望重写它的run()方法内的业务逻辑，所以我们可以实例化 Runnable 对象，作为 Thread 的构造参数. 使用Runnable 我们可以避免单继承的问题
这实际上是一种静态代理的设计模式

状态切换及相关方法

join:类方法，使调用该方法的线程进入就绪状态，阻塞其它线程，直到该线程执行完毕
yield:Thread 静态方法, 在哪个线程中调用，就使那个线程进入就绪状态，等待 cpu 调度
sleep:Thread 静态方法，与 yield 相比可以指定时间不会让出锁，多用于倒计时或模拟网络延时
currentThread:Thread 静态方法，在哪个线程中调用就返回哪个线程的引用
setPriority: MAX_PRIORITY -> 10, MIN_PRIORITY -> 1, NORM_PRRIORITY -> 0 优先级高的线程不能保证一定先执行，只是抢占资源时几率大一些，是否执行要服从 cpu 的调度

public static void main(String[] args) throws InterruptedException {
/**
 * 控制台会交替输出 1 和 2
 * 实际上多线程在很多情况下不是真正的并行
 * 而是 cpu 在极短的时间内不断切换线程来达到异步的效果
 */
    Thread t1 = new Thread() {
        @Override
        public void run() {
            super.run();
            int i = 1010;
            while (i-- > 0)
                System.out.println("1");
        }
    };
    Thread t2 = new Thread() {
        @Override
        public void run() {
            super.run();
            int i = 1010;
            while (i-- > 0)
                System.out.println("2");
        }
    };
    t1.start();
    t2.start();
}

当我们运行如下代码，就会发现所有的 2 会在 1 输出之后

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

下面的代码输出会出现同样的结果，因为我们在线程2中调用了静态方法 sleep，并且 1000ms 是一个足够让 t1 完成输出的时间

Thread t2 = new Thread() {
    @Override
    public void run() {
        super.run();
        int i = 1010;
        try {
            Thread.sleep(1000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        while (i-- > 0)
            System.out.println("2");
    }
};

锁

进程：资源分配的单位，进程间切换会有较大的开销
线程：调度和执行的单位，线程间切换开销较小，但是线程仍然具有独立的运行栈和计数器（PC）
多线程会涉及到并发问题，因为线程之间共享数据内存单元，内存地址，可以访问相同的变量和对象。而且该问题在无论是否是真正的并行条件下都出现.

下面的代码的输出结果为三个人都抢到了这台手机, 这就出现了多线程的中的并发问题，同时 MI 类中的 buy() 方法也被称为是线程不安全的

class MI {
    private int MIX3 = 1;

    public  boolean buy() throws InterruptedException {
        if (MIX3 > 0) {
            Thread.sleep(1000);//模拟交接手续耗时
            MIX3--;
            System.out.println("抢到了");
            return true;
        } else {
            System.out.println("没货了");
            return false;
        }
    }
}
public static void main(String[] args) {
    MI mi = new MI();
    Runnable buy = new Runnable() {
        @Override
        public void run() {
            try {
                mi.buy();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    };
    Thread t1 = new Thread(buy);
    Thread t2 = new Thread(buy);
    Thread t3 = new Thread(buy);
    t1.start();
    t2.start();
    t3.start();
}

我们可以通过在方法前加上synchronized关键字来是一个线程不安全的方法变为同步方法，当然安全就意味着效率的损失，所以我们也可以用同步块，仅使一部分代码变为同步

同步块
synchronized(引用类型){
注意作为锁的对象要保证引用不变，即为同一个对象
}
同步方法

静态代理

真实角色
代理角色（持有真实角色的引用）
二者实现相同的接口

比如当你结婚时，婚庆公司可以作为一个代理角色，帮助你结婚，但真正结婚的仍然是你，也就是说你是真实角色，而婚庆公司是代理角色，静态代理的好处就是，作为真实角色的你只需要关注最核心的事，也就是‘结婚’，其它的工作都可以交由代理角色处理

public class Main {
    public static void main(String[] args) {
        You you = new You();//真实对象
        ProxyCompany proxy = new ProxyCompany(you);//代理对象
        proxy.merry();
    }
}

/**
*二者要实现的相同的接口
*/
interface Merry {
    void merry();
}

class You implements Merry {

    @Override
    public void merry() {
        System.out.println("你和嫦娥结婚了");
    }
}

class ProxyCompany implements Merry {
    You you;//代理对象要持有真实对象引用

    public ProxyCompany() {
    }

    public ProxyCompany(You you) {
        this.you = you;
    }


    @Override
    public void merry() {
        before();
        you.merry();
        after();
    }
    private void before(){
        System.out.println("布置猪窝");
    }
    private void after(){
        System.out.println("闹猪窝");
    }
}

而动态代理模式唯一的区别就是代理类是在运行过程中动态创建的，实现的功能是一样的
至于为什么要讲静态代理模式，不难发现 Runnable 即为真实对象和代理对象同时实现的接口，Thread 为代理类, Thread 构造方法传入的参数即为真实对象.

Java--多线程

多线程

如何创建新的线程

状态切换及相关方法

锁

静态代理

猜你喜欢

热点阅读