精华内容
下载资源
问答
  • 详细介绍按照得多线程开发,handler消息机制,AsyncTask(异步操作),访问网络,访问sql sever 数据库。从网络上获取图片等开发所需基础知识,简单异动,照顾新手
  • 安卓开发多线程精讲一学就会 大学计算机专业毕业,从业IT四年,擅长java,...

    扫码下载「CSDN程序员学院APP」,1000+技术好课免费看

    APP订阅课程,领取优惠,最少立减5元 ↓↓↓

    订阅后:请点击此处观看视频课程

     

    视频教程-安卓开发多线程精讲一学就会-Android

    学习有效期:永久观看

    学习时长:129分钟

    学习计划:3天

    难度:

     

    口碑讲师带队学习,让你的问题不过夜」

    讲师姓名:朱祚华

    CTO/CIO/技术副总裁/总工程师

    讲师介绍:大学计算机专业毕业,从业IT四年,擅长java,html,微信公众号,小程序,安卓的开发,采用ssh框架比较多一些,经验丰富。

    ☛点击立即跟老师学习☚

     

    「你将学到什么?」

    详细介绍按照得多线程开发,handler消息机制,AsyncTask(异步操作),访问网络,访问sql sever 数据库。从网络上获取图片等开发所需基础知识,简单异动,照顾新手

     

    「课程学习目录」

    1.安卓开发为什么要非得学习多线程
    2.我是handler 消息机制
    3.handler访问网络图片
    4.用handler制作动态gif
    5.Handler访问数据库
    6.初识AsyncTask异步操作
    7.AsyncTask实战演练
    8.AsyncTask应该这样用
    9.安卓9.0的一个坑
    10.本套课程的总结与回顾

     

    7项超值权益,保障学习质量」

    • 大咖讲解

    技术专家系统讲解传授编程思路与实战。

    • 答疑服务

    专属社群随时沟通与讲师答疑,扫清学习障碍,自学编程不再难。

    • 课程资料+课件

    超实用资料,覆盖核心知识,关键编程技能,方便练习巩固。(部分讲师考虑到版权问题,暂未上传附件,敬请谅解)

    • 常用开发实战

    企业常见开发实战案例,带你掌握Python在工作中的不同运用场景。

    • 大牛技术大会视频

    2019Python开发者大会视频免费观看,送你一个近距离感受互联网大佬的机会。

    • APP+PC随时随地学习

    满足不同场景,开发编程语言系统学习需求,不受空间、地域限制。

     

    「什么样的技术人适合学习?」

    • 想进入互联网技术行业,但是面对多门编程语言不知如何选择,0基础的你
    • 掌握开发、编程技术单一、冷门,迫切希望能够转型的你
    • 想进入大厂,但是编程经验不够丰富,没有竞争力,程序员找工作难。

     

    「悉心打造精品好课,3天学到大牛3年项目经验」

    【完善的技术体系】

    技术成长循序渐进,帮助用户轻松掌握

    掌握Android知识,扎实编码能力

    【清晰的课程脉络】

    浓缩大牛多年经验,全方位构建出系统化的技术知识脉络,同时注重实战操作。

    【仿佛在大厂实习般的课程设计】

    课程内容全面提升技术能力,系统学习大厂技术方法论,可复用在日后工作中。

     

    「你可以收获什么?」

    学会handler消息机制

    了解AsyncTask(异步操作)

    知道如何访问网络以及数据

    从网络和数据得到图片要怎么处理

     

    展开全文
  • 如何理解安卓开发当中对多线程和多进程 如何理解安卓开发当中对多线程和多进程
  • 安卓多线程

    2018-04-16 22:27:56
    安卓多线程安卓高级开发中,必备技能,项目开发中都要使用
  • android的应用程序支持多线程多线程编程为我们充分利用系统资源提供了便利,同时也为设计复杂UI和耗时操作提供了途径,提升了安卓用户的使用体验。Android的多线程和JAVA没有多大变化,唯一的变化大概在于无法直接...

    android的应用程序支持多线程,多线程编程为我们充分利用系统资源提供了便利,同时也为设计复杂UI和耗时操作提供了途径,提升了安卓用户的使用体验。Android的多线程和JAVA没有多大变化,唯一的变化大概在于无法直接使用CANVAS修改屏幕元素,当然安卓为我们提供了surfaceview类来实现多线程中通过画布canvas修改屏幕。这为设计UI和开发游戏带来了方便。因此,研究和使用多线程编程,对我们深入学习安卓编程有着十分重要的作用。

      线程的方法比较多,常用的有:

      start();

      run();

      sleep();

      stop();

      destroy();

      join();

      suspend();

      resume();

      yield();

      wait();

      notify();

      线程启动一定要使用start方法,线程操作使用run方法,线程休眠使用sleep方法,线程停止使用stop,线程销毁使用destroy方法,线程同步使用JOIN方法,前面三种最常用,一般来说这三种就可以满足大部分线程使用需求,run结束时线程自动死亡,stop,destroy虽然也能停止线程,但不推荐使用,,前者会产生异常,后者是强制终止,不会释放锁,一般会在RUN里设置一个状态信号来等其自动结束,这里使用volatile boolean bThreadRun。后面是暂停,继续,挂起,由于会产生死锁问题,很少使用。大部分情况会使用wait和notify替代;

      这里我使用一个线程来计算变量并更新窗口标题。主要代码如下:使用eclipse创建一个项目。为Activity添加onStart,onPause, onStop等方法,Activity是我们最常使用的一个类,也是android的核心类,为应用程序管理并显示一个屏幕,开发的人不应该对其陌生。Activity活动主要的方法有,onCreate,onStart,onStop,onPause,onResume, onRestart,onDestroy,onRestoreInstanceState,onSaveInstanceState,一般的执行顺序是,onCreate,onStart,onResume,当窗口不是最顶层时,执行onPause,onstop,为顶层时,执行onRestart,onResume,一直循环,直到onDestroy.如果保存窗口,重载onSaveInstanceState,并在进入时重载onRestoreInstanceState。这里我在Activity的方法onStart里创建线程:

      01.MyThread myThread = new MyThread();

      02. myThread.start();

      在下面添加MyThread的实现代码:

      01.public class MyThread extends Thread {

      02. // 声明字符串变量

      03. public MyThread() {

      04. }

      05.

      06. @Override

      07. public void start() {

      08. super.start();

      09. }

      10.

      11. // 线程的主要工作方法

      12. @Override

      13. public void run() {

      14. while (true) {

      15. try {

      16. sleep(5000);

      17. if (c > ((1 << 31) - 1)) {

      18. c = 0;

      19. } else {

      20. c++;

      21. }

      22. Message message = new Message();

      23. message.what = 1;

      24. mHandler.sendMessage(message);

      25. } catch (InterruptedException ex) {

      26. }

      27. }

      28. }

      29.

      30. }

      实现updatetitle方法:

      01.public void updateTitle() {

      02. setTitle("test thread " + c);

      03. }

      这里没有使用updatetitle直接更新窗口,而是使用handler,这是因为直接使用是不安全的,会造成线程重启等问题。Android 引进了Handler 这个特殊的类,用它作为Runnable和Activity交互的桥梁,所以我们只能在run方法中发送Message,而在Handler里,通过不同的Message执行不同的任务。为程序添加handler;

      01.private Handler mHandler = new Handler() {

      02. public void handleMessage(Message msg) {

      03. switch (msg.what) {

      04. case 1:

      05. updateTitle();

      06. break;

      07. }

      08. };

      09. };

      最后完整的代码如下,使用线程处理数据,并把数据显示在窗口上:

      01.package com.test;

      02.

      03.import android.app.Activity;

      04.import android.os.Bundle;

      05.import java.lang.Thread;

      06.import android.os.Message;

      07.import android.os.Handler;

      08.import android.graphics.Color;

      09.

      10.public class TestThreadActivity extends Activity {

      11. int c = Color.BLUE;

      12. MyThread myThread;

      13. volatile boolean bThreadRun = false;

      14.

      15. /** Called when the activity is first created. */

      16. @Override

      17. public void onCreate(Bundle savedInstanceState) {

      18. super.onCreate(savedInstanceState);

      19. setContentView(R.layout.main);

      20. }

      21.

      22. @Override

      23. protected void onRestoreInstanceState(android.os.Bundle savedInstanceState) {

      24. super.onRestoreInstanceState(savedInstanceState);

      25. }

      26.

      27. @Override

      28. protected void onSaveInstanceState(android.os.Bundle outState) {

      29. super.onSaveInstanceState(outState);

      30. }

      31.

      32. @Override

      33. protected void onStart() {

      34. super.onStart();

      35. myThread = new MyThread();

      36. myThread.start();

      37. bThreadRun = true;

      38. }

      39.

      40. @Override

      41. protected void onRestart() {

      42. super.onRestart();

      43. }

      44.

      45. @Override

      46. protected void onResume() {

      47. super.onResume();

      48. }

      49.

      50. @Override

      51. protected void onPause() {

      52. super.onPause();

      53. bThreadRun = false;

      54. // myThread.stop();

      55. }

      56.

      57. @Override

      58. protected void onStop() {

      59. super.onStop();

      60. onPause();

      61. }

      62.

      63. @Override

      64. protected void onDestroy() {

      65. super.onDestroy();

      66. // myThread.destroy();

      67. }

      68.

      69. private Handler mHandler = new Handler() {

      70. public void handleMessage(Message msg) {

      71. switch (msg.what) {

      72. case 1:

      73. updateTitle();

      74. break;

      75. }

      76. };

      77. };

      78.

      79. public void updateTitle() {

      80. setTitle("test thread " + c);

      81. setTitleColor(c);

      82. }

      83.

      84. public class MyThread extends Thread {

      85. // 声明字符串变量

      86. public MyThread() {

      87. }

      88.

      89. @Override

      90. public void start() {

      91. super.start();

      92. }

      93.

      94. // 线程的主要工作方法

      95. @Override

      96. public void run() {

      97. while (bThreadRun) {

      98. try {

      99. sleep(100);

      100. if (c > ((1 << 16) - 1)) {

      101. c = 0;

      102. } else {

      103. c += 100;

      104. }

      105. Message message = new Message();

      106. message.what = 1;

      107. mHandler.sendMessage(message);

      108. } catch (InterruptedException ex) {

      109. }

      110. }

      111. }

      112.

      113. }

      114.

      115.}

      线程还有另外一种常用的方法是编写Runnable接口,这里对代码做一些修改,使用线程实现对主窗口重绘,全部代码如下:

      01.package com.test;

      02.

      03.import android.app.Activity;

      04.import android.content.Context;

      05.import android.os.Bundle;

      06.import java.lang.Thread;

      07.import android.view.View;

      08.import android.graphics.Canvas;

      09.import android.graphics.Color;

      10.import android.graphics.Paint;

      11.import android.graphics.Paint.Style;

      12.import android.graphics.Rect;

      13.

      14.public class TestThreadActivity extends Activity {

      15. int c = Color.BLUE;

      16. MyThread myThread;

      17. volatile boolean bThreadRun = false;

      18. MyView mv;

      19.

      20. /** Called when the activity is first created. */

      21. @Override

      22. public void onCreate(Bundle savedInstanceState) {

      23. super.onCreate(savedInstanceState);

      24. // setContentView(R.layout.main);

      25. mv = new MyView(this);

      26. setContentView(mv);

      27. }

      28.

      29. public class MyView extends View {

      30. MyView(Context context) {

      31. super(context);

      32. }

      33.

      34. @Override

      35. protected void onDraw(Canvas canvas) {

      36. // TODO Auto-generated method stub

      37. super.onDraw(canvas);

      38.

      39. // 首先定义一个paint

      40. Paint paint = new Paint();

      41.

      42. // 绘制矩形区域-实心矩形

      43. // 设置颜色

      44. paint.setColor(c);

      45. // 设置样式-填充

      46. paint.setStyle(Style.FILL);

      47. // 绘制一个矩形

      48. canvas.drawRect(new Rect(0, 0, getWidth(), getHeight()), paint);

      49. }

      50.

      51. }

      52.

      53. @Override

      54. protected void onRestoreInstanceState(android.os.Bundle savedInstanceState) {

      55. super.onRestoreInstanceState(savedInstanceState);

      56. }

      57.

      58. @Override

      59. protected void onSaveInstanceState(android.os.Bundle outState) {

      60. super.onSaveInstanceState(outState);

      61. }

      62.

      63. @Override

      64. protected void onStart() {

      65. super.onStart();

      66. //myThread = new MyThread();

      67. //myThread.start();

      68. new Thread (new MyThread()).start();

      69. bThreadRun = true;

      70. }

      71.

      72. @Override

      73. protected void onRestart() {

      74. super.onRestart();

      75. }

      76.

      77. @Override

      78. protected void onResume() {

      79. super.onResume();

      80. }

      81.

      82. @Override

      83. protected void onPause() {

      84. super.onPause();

      85. bThreadRun = false;

      86. // myThread.stop();

      87. }

      88.

      89. @Override

      90. protected void onStop() {

      91. super.onStop();

      92. onPause();

      93. }

      94.

      95. @Override

      96. protected void onDestroy() {

      97. super.onDestroy();

      98. // myThread.destroy();

      99. }

      100.

      101. public class MyThread implements Runnable{

      102. // 线程的主要工作方法

      103. @Override

      104. public void run() {

      105. while (bThreadRun) {

      106. try {

      107. Thread.sleep(500);

      108. if (c > ((1 << 31) - 1)) {

      109. c = 0;

      110. } else {

      111. c += 100;

      112. }

      113. mv.postInvalidate();

      114. } catch(InterruptedException e){

      115. }

      116. }

      117. }

      118.

      119. }

      120.

      121.}

    展开全文
  • 安卓开发多线程与异步任务

    千次阅读 2015-12-27 10:25:25
    在Android开发中有时候需要进行一些耗时的操作,如网络请求或者IO操作,如果你使用的是Android4.0以后,那你会发现,只要是写在UI线程中的HTTP请求,运行时都会报错,这是因为Android在4.0以后为了防止应用的ANR...

    在Android开发中有时候需要进行一些耗时的操作,如网络请求或者IO操作,如果你使用的是Android4.0以后,那你会发现,只要是写在UI线程中的HTTP请求,运行时都会报错,这是因为Android在4.0以后为了防止应用的ANR(aplication Not Response)异常

      在Android API>9 (Honeycomb及之后)版本里,对UI线程/主线程里是不允许联网操作的,如果有网络操作,会抛出NetworkOnMainThreadException的异常。
    

    为了避免ANR(Application Not Response)异常,可以把网络请求或IO操作用多线程来完成,或者使用AsyncTask。

    多线程

    一.创建线程

    1.Thread类
    继承Thread类,Override 其 run(){}方法,然后调用start()方法即可启动子线程。
    new Thread() {
    @Override
    public void run(){
    super.run();
    //do something
    }
    }.start();

    2.Runnable接口
    实现Runnable接口中的run(){}方法,但是注意,Runnable并不提供start()方法,因此需要使用Thread的public Thread(Runnable targer)构造方法来实现开线程。
    class MyRunnable implements Runnable{
    @Override
    public void run(){
    //do something
    }
    }
    MyRunnable mt = new MyRunnable();
    new Thread(a).start();

    注意:Runnable相比于直接继承Thread的优势:
    (1)java只支持单继承的方式,继承Thread不够灵活,而一个类可以实现多个接口。
    (2)实现Runnable接口,可以让同一个类开多条线程,使用synchronized方法修饰run()方法,即可实现多线程之间的资源共享。
    class MyRunnable implements Runnable{
    @Override
    public synchronized void run(){
    //do something
    } }
    MyRunnable a = new MyRunnable();
    MyRunnable b = new MyRunnable();
    new Thread(a).start();
    new Thread(b).start();

    3.使用Timer调度TimerTask
    使用Timer不仅可以定时执行任务,也可以配合TimerTask执行多线程操作。
    class myTimeTask extends TimerTask{
    @Override
    public void run() {
    //do something
    //System.gc();
    }
    }
    Timer timer = new Timer();
    timer.schedule(new myTimeTask(),1000);//1秒后执行任务

    注意:
    (1)如果使用同一个Timer()来调度,前一个TimerTask执行完后才会执行下一个,需要同时开多线程的时候,应使用多个Timer()来分别调度。
    (2)程序的Timer线程在运行时,这个程序就会保持运行,需要终止Timer线程时可以调用Timer的cancle()方法。
    (3)Timer中的TimerTask执行完后,整个程序并不会退出,需要等待垃圾回收时程序才会退出,所以可以在run方法最后加上System.gc();

    4.ThreadPoolExecutor线程池

    二.使用Handler
    安卓中不允许在子线程中操作UI,因为UI主线程并不线程安全,所以要在子线程中操作UI,需要使用Handler机制。
    创建子类继承Handler,并Override其handleMessage(Message msg)方法,即可根据Message对象的值在函数体中操作UI。
    同时,在子线程中新建Message,并通过sendMessage()来传递消息。
    Message可以携带的数据有

    arg1: int 存放整型数据 
    arg2: int 存放整型数据
    obj: Object 存放Object类型的任意对象
    replyTo: Messenger 用来指定此Message发送到何处的可选Messager对象
    what: int 用户自定义消息代码
    

    例如:
    private Handler mHandler = new Handler(){
    @Override
    public void handleMessage(Message msg){
    super.handleMessage(msg);
    //do something
    }
    };
    new Thread() {
    @Override
    public void run() {
    super.run();
    Message msg = new Message();
    msg.obj = Object;
    mHandler.sendMessage(msg);
    }
    }.start();

    异步任务 AsyncTask

    展开全文
  • 参考资料:郭霖第一行代码及网上公开资料这里只是简单的介绍一下java多线程的知识,然后主要讲解的是安卓如何在子线程中更新UI当我们需要执行一些耗时操作,比如说发起一条网络请求,考虑到网速等其他原因,服务器...

    参考资料:郭霖第一行代码及网上公开资料

    这里只是简单的介绍一下java多线程的知识,然后主要讲解的是安卓如何在子线程中更新UI

    当我们需要执行一些耗时操作,比如说发起一条网络请求,考虑到网速等其他原因,服务器未必会立刻

    响应我们的请求,如果不将这类操作放在子线程里去执行,就会导致主线程被阻塞住,从而影响用户对

    软件的正常使用。


    1.继承Thread类

    class MyThread extends Thread{
    
    	@Override
    	public void run() {
    		//处理具体的逻辑
    	}
    }
    
    然后通过new MyThread.start()方法启动

    2.实现Runnable接口

    Thread的构造函数接受一个Runnable参数,而我们new出的MyThread正是一个实现了Runnable接口

    的对象,所以可以直接传入。

    class MyThread implements Runnable{
    
    	@Override
    	public void run() {
    		//处理具体的逻辑
    	}
    }
    
    使用了这种写法,启动线程的方法也需要进行相应的改变
    MyThread myThread = new MyThread();
    new Thread(myThread).start()

    如果不想再专门定义一个类去实现Runnable接口,可以使用匿名类的方式

    new Thread(new Runnable(){
    
    	@Override
    	public void run() {
    		//处理具体的逻辑
    	}
    }).start();

    二者耦合性区别:

    第一种方式,继承Thread类,线程任务和线程对象绑定在一起,耦合性较高,不便于维护

    第二种方式,实现Runnable接口,线程任务在实现Runnable接口的类中,线程对象是Thread对象

    ,线程任务和线程对象相分离,耦合性低,便于维护

    线程的生命周期: 

    (1)生命周期的五种状态

     新建(new Thread)
    当创建Thread类的一个实例(对象)时,此线程进入新建状态(未被启动)。
    例如:Thread  t1=new Thread();

    就绪(runnable)
    线程已经被启动,正在等待被分配给CPU时间片,也就是说此时线程正在就绪队列中排队等候得到CPU资源。例如:t1.start();

    运行(running)
    线程获得CPU资源正在执行任务(run()方法),此时除非此线程自动放弃CPU资源或者有优先级更高的线程进入,线程将一直运行到结束。

    死亡(dead)
    当线程执行完毕或被其它线程杀死,线程就进入死亡状态,这时线程不可能再进入就绪状态等待执行。

    自然终止:正常运行run()方法后终止

    异常终止:调用stop()方法让一个线程终止运行

    堵塞(blocked)
    由于某种原因导致正在运行的线程让出CPU并暂停自己的执行,即进入堵塞状态。

    正在睡眠:用sleep(long t) 方法可使线程进入睡眠方式。一个睡眠着的线程在指定的时间过去可进入就绪状态。

    正在等待:调用wait()方法。(调用motify()方法回到就绪状态)

    被另一个线程所阻塞:调用suspend()方法。(调用resume()方法恢复)

    2.常用方法

    void run()   创建该类的子类时必须实现的方法

    void start() 开启线程的方法

    static void sleep(long t) 释放CPU的执行权,不释放锁

    static void sleep(long millis,int nanos)

    final void wait()释放CPU的执行权,释放锁

    final void notify()

    static void yied()可以对当前线程进行临时暂停(让线程将资源释放出来)


    在子线程中更新UI

    和许多其他的GUI库一样,Android的UI也是线程不安全的。也就是说,如果想要更新应用程序里的UI元素,则必须在主线程中进行,否则就会出现异常。

    新建AndroidThreadTest项目

    修改activity_main.xml文件

    <?xml version="1.0" encoding="utf-8"?>
    <LinearLayout xmlns:android="http://schemas.android.com/apk/res/android"
        android:layout_width="match_parent"
        android:layout_height="match_parent">
    
        <Button
            android:id="@+id/change_text"
            android:layout_width="match_parent"
            android:layout_height="wrap_content"
            android:text="Change Text"/>
    
        <TextView
            android:id="@+id/text"
            android:layout_width="wrap_content"
            android:layout_height="wrap_content"
            android:layout_centerInParent="true"
            android:text="Hello world"
            android:textSize="20sp"/>
    
    </LinearLayout>

    然后修改MainActivity.java

    package com.gougoucompany.clarence.androidthreadtest;
    
    import android.support.v7.app.AppCompatActivity;
    import android.os.Bundle;
    import android.view.View;
    import android.widget.Button;
    import android.widget.TextView;
    
    public class MainActivity extends AppCompatActivity implements View.OnClickListener{
    
        private TextView text;
    
        @Override
        protected void onCreate(Bundle savedInstanceState) {
            super.onCreate(savedInstanceState);
            setContentView(R.layout.activity_main);
            text = (TextView) findViewById(R.id.text);
            Button changeText = (Button) findViewById(R.id.change_text);
            changeText.setOnClickListener(this);
        }
    
        @Override
        public void onClick(View v) {
            switch(v.getId()) {
                case R.id.change_text:
                    new Thread(new Runnable(){
                        @Override
                        public void run() {
                            text.setText("Nice to meet you");
                        }
                    }).start();
                    break;
                default:
                    break;
            }
        }
    }
    

    我们运行会发现程序崩溃了,由此证实了Android不允许在子线程中进行UI操作。

    android.view.ViewRootImpl$CalledFromWrongThreadException: Only the original 
    thread that created a view hierarchy can touch its views.           

    对于这种情况,Android提供了异步消息处理机制.

    修改MainActivity.java

    package com.gougoucompany.clarence.androidthreadtest;
    
    import android.os.Handler;
    import android.os.Message;
    import android.support.v7.app.AppCompatActivity;
    import android.os.Bundle;
    import android.view.View;
    import android.widget.Button;
    import android.widget.TextView;
    
    public class MainActivity extends AppCompatActivity implements View.OnClickListener{
    
    
        public static final int UPDATE_TEXT = 1;
    
        private TextView text;
    
        //新增一个Handler对象,并重写父类的handleMessage方法
        private Handler handler = new Handler(){
    
            @Override
            public void handleMessage(Message msg) {
                switch (msg.what) {
                    case UPDATE_TEXT:
                        //在这里可以进行UI操作
                        text.setText("Nice to meet you");
                        break;
                    default:
                        break;
                }
            }
        };
    
        @Override
        protected void onCreate(Bundle savedInstanceState) {
            super.onCreate(savedInstanceState);
            setContentView(R.layout.activity_main);
            text = (TextView) findViewById(R.id.text);
            Button changeText = (Button) findViewById(R.id.change_text);
            changeText.setOnClickListener(this);
        }
    
        @Override
        public void onClick(View v) {
            switch(v.getId()) {
                case R.id.change_text:
                    new Thread(new Runnable(){
                        @Override
                        public void run() {
                            /*在子线程中没有直接进行UI操作,而是创建了一个android.os.Message对象
                            并将它的what字段指定为UPDATE_TEXT,然后调用Handler的sendMessage()方法将
                            这条message发送出去,然后Handler会收到message,然后在handleMessage()方法
                            中对它进行处理*/
                           Message message = new Message();
                            message.what = UPDATE_TEXT;
                            handler.sendMessage(message); //将Message对象发送出去
                        }
                    }).start();
                    break;
                default:
                    break;
            }
        }
    }

    注意:handleMessage()方法中的代码就是在主线程当中运行的,可以放心的进行UI更改操作

    下面是一个博客写的非常好,主要讲解异步消息处理的原理Android异步消息处理机制 Android异步消息处理机制

    展开全文
  • 安卓开发-多线程操作Sqlite问题

    千次阅读 2013-07-24 16:02:48
    Sqlite数据库本身是不支持多线程同时操作的。 如果使用多个线程来操作Sqlite,可能会遇到像这样的问题:一个线程中使用完db之后直接调用 了db.close(),但是由于在一个sqlite数据库中,得到的SqliteDatabase对象是...
  • 我可以说一下我解决问题的方式,将复杂问题划分成多个简单的问题多线程下载一:请点击这里多线程下载二:请点击这里权限: <uses-permission android:name="android.permission.INTERNET"></uses-permission> ...
  • 学习目标01知识目标理解多线程的概念掌握两种多线程的实现方法02能力目标会使用继承Thread类和实现Runnable接口两种方法完成多线程多线程的概念什么是多线程多线程multi-thread是指在单个的程序内可以同时运行多个...
  • 安卓中不能在子线程中更新UI,否则会报错,此时需要借助Handler,见示例package com.example.administrator.threadhello; import android.os.Handler; import android.os.Message; import android.support.v7....
  • 《方式一:多线程下载之常规实现》 原理如图: 1.创建urlURL url = new URL(getUrl());//下载来自tomcat下的webapps/ROOT/resource.rar文件,10.0.2.2是安卓映射的服务器的地址,此时不再是localhost或者是本机...
  • 课程编排重在实用,讲解通俗易懂 让您在最短的时间内学会最需要的知识点——窗体
  • 最近在研究Unity3D开发中使用Java Plugin进行纹理更新,想法很简单,在Java线程更新纹理数据,然后Unity场景中的纹理将自动更新。 首先,创建Java类,定义创建纹理及获取纹理参数的接口,并创建单线程池用于进行...
  • styles.xml 往styles.xml里添加下面的主题格式,改变日期视图字体颜色与选中的颜色 @android:color/black @android:color/holo_blue_light @android:color/holo_blue_dark calendarview.xml布局构思 ...
  • Android只会存在两种线程:UI主线程(UI thread)和工作线程(work thread). 我们知道Android的UI主线程主要负责处理用户的按键事件、用户的触屏事件以及屏幕绘图事件等,在子线程中处理耗时的任务,任务完成后通过...
  • 实 验 报 告 2013/2014 学年 第一学期 课程名称 软件技术系列课程 Android 基础 实验名称 Android 广播线程服务与多媒体开发 实验时间 2013 年 12 月 9 日 指导单位 计算机学院诚迈科技南京公司 指导教师 学生姓名 ...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 451
精华内容 180
关键字:

安卓开发多线程