线程的知识-CSDN博客

本文链接：https://blog.csdn.net/fusu2178192/article/details/122946440

本文详细介绍了Android中线程的使用，包括Timer、Thread、Runnable和Callable接口的实现，以及线程的中断、优先级设置和线程池的概念。示例代码展示了线程的创建、同步和控制，为理解Android应用中的多线程操作提供了实践指导。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

package com.example.myapplication;

import androidx.appcompat.app.AppCompatActivity;

import android.content.res.Configuration;
import android.content.res.Resources;
import android.os.Bundle;
import android.util.DisplayMetrics;
import android.util.Log;
import android.widget.TextView;

import java.util.Locale;
import java.util.Timer;
import java.util.TimerTask;
import java.util.concurrent.Callable;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.FutureTask;

/**
 * 主页面：练习线程
 *
 * @author
 */
public class MainActivity extends AppCompatActivity {

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_main);


        //定时器，也是一个线程
        Timer timer = new Timer();//  Timer timer = new Timer(ture);设置其成为守护线程
        timer.schedule(new TimerTask() {
            @Override
            public void run() {
                int i = 0;
                Log.d("TAG", "run:============================ " + i++);

            }
        }, 0, 1000);

        Thread myThread = new Thread(new MyThread());
        myThread.start();//只有通过这种方式才能抢占主线程CPU的时间片
        try {
            Thread.sleep(5000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
//        myThread.interrupt();//实例方法方法谁调用就唤醒谁（通过sleep的异常处理方式终止睡眠）
        myThread.setPriority(7);//实例方法设置线程优先级（最高10,默认5,最低1）
        myThread.getPriority();//获取线程优先级
//        Thread.yield();//线程让位，静态方法使当前线程主动让位从运行状态变为就绪状态，但会继续抢夺时间片
//        try {
//            myThread.join();//合并线程，实例方法当前线程需要等待myThread线程执行完毕才能执行（栈没有合并，只是产生了等待关系）
//        } catch (InterruptedException e) {
//            e.printStackTrace();
//        }
        for (int i = 0; i < 10; i++) {
            Log.d("TAG", "main: ===========" + i);
            try {
                Thread.sleep(1000);//sleep()是静态方法在哪个线程里调用就会睡眠那个线程，利用他可以完成时间间隔的代码
//                只能try/catch因为子类不能比父类抛出更多的异常
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }

        Thread thread = Thread.currentThread();//获取当前线程对象
        thread.setName("main01");      //设置线程名字
        String t = thread.getName();//获取当前线程名字
        Log.d("TAG", "onCreate: ===========" + t);

        new Thread(new Runnable() {//匿名内部类的方式创建线程会在主线程运行之后运行
            @Override
            public void run() {
                Thread thread1 = Thread.currentThread();
                String t1 = thread1.getName();
                for (int i = 0; i < 10; i++) {
                    Log.d("TAG", "thead03: ===========" + i);
                    try {
                        Thread.sleep(1000);//sleep()是静态方法在哪个线程里调用就会睡眠那个线程，利用他可以完成时间间隔的代码
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }
                Log.d("TAG", "onCreate111111: ===========" + t1);

            }
        }).start();
        new Thread(new Runnable() {
            @Override
            public void run() {
                Thread thread11 = Thread.currentThread();
                String t11 = thread11.getName();
                Log.d("TAG", "onCreate11111111111111: ===========" + t11);

            }
        }).start();//开辟一个新的栈（很快）


        //创建线程的第三种方式实现Callable接口
        FutureTask futureTask = new FutureTask(new Callable() {
            @Override
            public Object call() throws Exception {
                Log.d("TAG", "call: ============start");
                Thread.sleep(3000);
                Log.d("TAG", "call: ============end");
                int a = 100;
                int b = 200;
                return a + b;
            }
        });
        Thread threadcall = new Thread(futureTask);
        threadcall.start();
        try {
            Object obj = futureTask.get();//获取线程返回的值
        } catch (ExecutionException e) {
            e.printStackTrace();
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        Log.d("TAG", "okokokokokokkokkokokookoko");
    }


}

class MyThread implements Runnable {
    boolean run = true;

    //    当需要中止线程时只需要
//    MyThread myThread = new MyThread();
//    myThread.run = flase;
    @Override
    public void run() {
        if (run) {
            for (int i = 0; i < 10; i++) {
                Log.d("TAG", "MyThread: ===========" + i);
                try {
                    Thread.sleep(2000);//sleep()是静态方法在哪个线程里调用就会睡眠那个线程，利用他可以完成时间间隔的代码
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        } else {
            return;
        }

//            try {
//                Thread.sleep(1000*60*60*10);
//            } catch (InterruptedException e) {
//                e.printStackTrace();
//            }
        Log.d("TAG", "MyThread: ===========end");
    }


}

线程池的使用方法：Android线程池_qinchun_long的博客-CSDN博客_android 线程池