android 多线程

day_moon

已于 2022-03-20 22:51:04 修改

阅读量1.3k

点赞数

分类专栏： android基础文章标签： android java apache

于 2022-02-23 18:09:18 首次发布

本文链接：https://blog.csdn.net/day_moon/article/details/123094840

版权

android基础专栏收录该内容

28 篇文章 0 订阅

订阅专栏

1.多线程循环

public class MainActivity extends AppCompatActivity {
    private boolean running = false;
    //handler
    Handler handler=new Handler(Looper.myLooper()){
        @Override
        public void handleMessage(@NonNull Message msg) {
            super.handleMessage(msg);
            Log.e("** handler *", "** handleMessage **");
            Message message=  Message.obtain();
            handler.sendMessageDelayed(message,500);
        }
    };

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_main);
        initThread();
    }
    Thread thread;
    public void initThread() {
        Runnable runnable = new Runnable() {
            @Override
            public void run() {
                while (!running) {
                    Log.e("** runnable *", "***");
                }
                running = true;
            }
        };
//        Runnable runnable1 = new Runnable() {
//            @Override
//            public void run() {
//                while (true) {
//                    Log.e("** runnable1 *", "***");
//
//                }
//            }
//        };
//        //线程
//        thread = new Thread(
//                runnable
//        );
//        thread.start();
//        //线程池
//        executorService = Executors.newFixedThreadPool(2);
//        executorService.execute(runnable1);

//       //handler方式  handler
        Message message=  Message.obtain();
        handler.sendMessageDelayed(message,500);//发消息方式
        handler.postDelayed(runnable,500);//发runnable方式
    }
    ExecutorService executorService;
    @Override
    protected void onDestroy() {
        super.onDestroy();
        if (running) {
            running = false;
        }
        if (!executorService.isShutdown()) {
            executorService.shutdown();
        }
    }
}

2.handler 主子线程之间传值

(1)子线程向主线程传值

    //handler
    Handler handler=new Handler(){//主线程
        @Override
        public void handleMessage(@NonNull Message msg) {
            super.handleMessage(msg);
            Log.e("** handler *", "** handleMessage **");

        }
    };
    Thread thread;
    public void initThread() {
        Runnable runnable = new Runnable() {
            @Override
            public void run() {
                Message message=  Message.obtain();
                handler.sendMessage(message);
            }
        };
        //线程
        thread = new Thread(
                runnable
        );
        thread.start();//子线程发送
    }

2.(2)子线程向子线程传值

 //handler
    Handler childHandler;
    public void initThread() {
        tv_button=findViewById(R.id.tv_buttons);
        //子线程
        tv_button.setOnClickListener(new View.OnClickListener() {
            @Override
            public void onClick(View view) {
                new Thread(new Runnable() {
                    @Override
                    public void run() {
                        Looper loop = Looper.myLooper();
                        Message msg = childHandler.obtainMessage();
                        msg.obj = "btn2当中子线程";
                        childHandler.sendMessage(msg);
                    }
                }).start();
            }
        });
        //子线程
        new Thread(new Runnable() {
            @Override
            public void run() {
                String msg;
                Looper.prepare();
                childHandler = new Handler() {
                    @Override
                    public void handleMessage(Message msg) {
                        super.handleMessage(msg);
                        Log.e("****","****"+msg.obj);
                    }
                };
                Looper.loop();//开始轮循
            }
        }).start();

2.(3)主线程向子线程里发送消息

    private Handler mHandler;//将mHandler指定轮询的Looper
    public void initThread() {
        //实例化一个特殊的线程HandlerThread，必须给其指定一个名字
        HandlerThread thread = new HandlerThread("handler thread");
        thread.start();//千万不要忘记开启这个线程
        //将mHandler与thread相关联
        mHandler = new Handler(thread.getLooper()){
            public void handleMessage(android.os.Message msg) {
                Log.d("当前子线程是----->", Thread.currentThread()+"");
            };
        };
        //主线程 发送消息
        mHandler.sendEmptyMessage(1);
    }

线程的创建

 button1 = findViewById(R.id.button);
        button2 = findViewById(R.id.button2);
        Mythread mythread = new Mythread();
//
//
//       new Thread(new Runnable() {
//           @Override
//           public void run() {
//               Log.e("我是线程1","我是线程");//2.通过接口的方式
//           }
//       }).start();

//        //打开  用类的方式 可以单独写进类
//        button2.setOnClickListener(new View.OnClickListener() {
//            @Override
//            public void onClick(View view) {
                mythread.start();
//                thread.start();
//            }
//        });
//        //关闭
//        button1.setOnClickListener(new View.OnClickListener() {
//            @Override
//            public void onClick(View view) {
                mythread.interrupt();//中断线程
//                thread.interrupt();//中断线程
//                if (mythread.isAlive()) {
//                    Log.e("我是线程1", "线程活着");//1.通过接口的方式
//                } else {
//                    Log.e("我是线程1", "线程死了");//2.通过接口的方式
//                }
//            }
//        });
//        ReentrantLock rwl = new ReentrantLock();

        Runnable runnable = new Runnable() {
               int count=100;
            @Override
            public void run() {
                extracted();
            }
            private synchronized void extracted() {
//                rwl.lock();
                boolean running=true;
                while (running){
                    count=count-1;
                    if (count<0){
                        running=false;
                    }
                    Log.e("****", "线程=="+Thread.currentThread().getName()+"count="+count);//2.通过接口的方式
                    Log.e("****", "线程=="+Thread.currentThread().getName()+"count="+count);//2.通过接口的方式
                    Log.e("****", "线程=="+Thread.currentThread().getName()+"count="+count);//2.通过接口的方式
                }
//                rwl.unlock();
            }
        };
        Thread thread1= new Thread(runnable,"线程一");
        Thread thread2= new Thread(runnable,"线程二");
        Thread thread3= new Thread(runnable,"线程三");
        thread1.start();
        thread2.start();
        thread3.start();

定时器

       //1.定时器
//        Timer timer=new Timer();
//        TimerTask timerTask=new TimerTask() {
//            @Override
//            public void run() {
//                Log.e("***","定时器");
//            }
//        };
//        timer.schedule(timerTask,1000,3000);//第一次1秒后 后面每隔3秒

        //2.Thread+while的方式
//          new Thread(new Runnable() {
//              @Override
//              public void run() {
//                  while (true){
//                      try {
//                          Thread.sleep(1000);
//                          Log.e("***","定时器");
//                      } catch (InterruptedException e) {
//                          e.printStackTrace();
//                      }
//                  }
//              }
//          }).start();

        //3.Handler方式
//        Handler handler=new Handler();
//        Runnable runnable=new Runnable() {
//            @Override
//            public void run() {
//                handler.postDelayed(this,1000);
//                Log.e("***","定时器");
//            }
//        };
//        handler.postDelayed(runnable,1000);

        //4.线程池的方式
        ScheduledExecutorService executorService= Executors.newSingleThreadScheduledExecutor();
       Runnable runnable=new Runnable() {
           @Override
           public void run() {
               Log.e("***","定时器");
           }
       };
        executorService.scheduleWithFixedDelay(runnable,0,1000,TimeUnit.MILLISECONDS);//0延时，每隔100毫秒执行一次

Future

public class CallableDemo implements Callable<Integer> {
    private int sum;
    @Override
    public Integer call() throws Exception {
        System.out.println("Callable子线程开始计算啦！");
        Thread.sleep(2000);

        for(int i=0 ;i<5000;i++){
            sum=sum+i;
        }
        System.out.println("Callable子线程计算结束！");
        return sum;
    }
}
//创建线程池
//        ExecutorService es = Executors.newSingleThreadExecutor();
//        //创建Callable对象任务
//        CallableDemo calTask=new CallableDemo();
//        //提交任务并获取执行结果
//        Future<Integer> future =es.submit(calTask);
//        //关闭线程池
//        es.shutdown();
//        try {
//            Thread.sleep(2000);
//            System.out.println("主线程在执行其他任务");
//
//            if(future.get()!=null){
//                //输出获取到的结果
//                System.out.println("future.get()-->"+future.get());
//            }else{
//                //输出获取到的结果
//                System.out.println("future.get()未获取到结果");
//            }
//
//        } catch (Exception e) {
//            e.printStackTrace();
//        }
//        System.out.println("主线程在执行完成");

ConcurrentLinkedQueue

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

//        ConcurrentLinkedDeque con=new ConcurrentLinkedDeque();
//        con.offer("nihao");//offer是往队列添加元素
//        con.peek();//只是获取不移除此队列的头
//        con.poll();//获取并移除此队列的头
//        Log.e("***1***","队列=="+con.isEmpty());
//        Log.e("***1***","队列=="+con.remove("nihao"));//remove一个已存在元素，会返回true，remove不存在元素，返回false

        int peopleNum = 10000;//吃饭人数
        int tableNum = 10;//饭桌数量

        ConcurrentLinkedQueue<String> queue = new ConcurrentLinkedQueue<>();
        CountDownLatch count = new CountDownLatch(tableNum);//计数器

        //将吃饭人数放入队列（吃饭的人进行排队）
        for(int i=1;i<=peopleNum;i++){
            queue.offer("消费者_" + i);
        }
        //执行10个线程从队列取出元素（10个桌子开始供饭）
        System.out.println("-----------------------------------开饭了-----------------------------------");
        long start = System.currentTimeMillis();
        ExecutorService executorService = Executors.newFixedThreadPool(tableNum);
        for(int i=0;i<tableNum;i++) {
            executorService.submit(new Dinner("00" + (i+1), queue, count));
        }
        //计数器等待，知道队列为空（所有人吃完）
        try {
            count.await();
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        long time = System.currentTimeMillis() - start;
        System.out.println("-----------------------------------所有人已经吃完-----------------------------------");
        System.out.println("共耗时：" + time);
        //停止线程池
        executorService.shutdown();
    }
    class Dinner implements Runnable{
        private String name;
        private ConcurrentLinkedQueue<String> queue;
        private CountDownLatch count;

        public Dinner(String name, ConcurrentLinkedQueue<String> queue, CountDownLatch count) {
            this.name = name;
            this.queue = queue;
            this.count = count;
        }

        @Override
        public void run() {
            //while (queue.size() > 0){
            while (!queue.isEmpty()){
                //从队列取出一个元素 排队的人少一个
                System.out.println("【" +queue.poll() + "】----已吃完...， 饭桌编号：" + name);
            }
            System.out.println("----111...");
            count.countDown();//计数器-1
        }
    }

LinkedBlockingQueue

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

        BlockingQueue blockingQueue = new LinkedBlockingQueue(5);//定义一个大小为5的盒子，表示可以阻塞几个线程
        new Thread(new ProducerQueue(blockingQueue)).start();
        new Thread(new ConsumerQueue(blockingQueue)).start();
    }
    static class ProducerQueue implements Runnable {
        private BlockingQueue producerQueue;
        public ProducerQueue(BlockingQueue producerQueue) {
            this.producerQueue = producerQueue;
        }
        @Override
        public void run() {
            for (int i = 0; i < 10; i++) {
                try {
                    System.out.println("生产者生产了第 " + i + " 个产品");
                    producerQueue.put(i);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        }
    }
    static class ConsumerQueue implements Runnable {
        private BlockingQueue consumerQueue;
        public ConsumerQueue(BlockingQueue consumerQueue) {
            this.consumerQueue = consumerQueue;
        }
        @Override
        public void run() {
            for (int i = 0; i < 10; i++) {
                try {
                    System.out.println("消费者消费了第 " + i + " 个产品");
                    consumerQueue.take();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        }
    }

day_moon

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
android 多线程

1.多线程循环public class MainActivity extends AppCompatActivity { private boolean running = false; //handler Handler handler=new Handler(Looper.myLooper()){ @Override public void handleMessage(@NonNull Message msg) {
复制链接

扫一扫

专栏目录