新人培训 – 线程&Handler

多线程


本次培训要搞清的几个问题
1.什么是线程
2.为什么Android只允许在主线程更新UI
3.如何异步进行耗时操作后在主线程执行回调更新UI
4.Handler的基本原理


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

  • 新建线程需要调用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 构造方法传入的参数即为真实对象.


2.Android中如何切换到主线程
– Handler机制

//Handler要在你需要切换到的目标线程创建
Handler handler = new Handler() {
    @Override
    public void handleMessage(Message msg) {
        super.handleMessage(msg);
        if(msg.what==1)
            textView.setText((String)msg.obj);
        }
    }
};
//在其它线程发送message
Message message = handler.obtainMessage();
    message.what = 1;
    message.obj="result";
    handler.sendMessage(message);
  • view.post(Runnable action)
    1. view.post 中的代码可以对UI进行操作
    2. view.post 中可以拿到 View 测绘后的宽高
  • activity.runOnUiThread(Runnable action)
 new Thread(new Runnable() {

            @Override
            public void run() {

                //延迟两秒
                try {
                    Thread.sleep( 2000 );
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }

                runOnUiThread(new Runnable() {
                    @Override
                    public void run() {
                        Toast.makeText(MainActivity.this, "hah", Toast.LENGTH_SHORT).show();
                    }
                });

            }
        }).start();
public final void runOnUiThread(Runnable action) {
    if (Thread.currentThread() != mUiThread) {
        mHandler.post(action);
    } else {
        action.run();
    }
}
  • 使用AsyncTask
    自行了解

3.Handler基本原理
– 为什么会出现ANR
– Handler、Looper、Message、MessageQueue
– 每个线程只能绑定一个 Looper,否则在调用 prepare 时会报错,调用 loop() 函数后开始死循环
– looper 从 MessageQueue 中取 Msg 传递给 HandleMsg 方法
– 1 个线程 Thread 只能绑定 1个循环器 Looper,但可以有多个处理者 Handler

参考

https://www.cnblogs.com/cowboys/p/9315331.html

发表评论

邮箱地址不会被公开。 必填项已用*标注