Android-Thread

Thread

进程:是计算机中的程序关于某数据集合上的一次运行活动,是系统进行资源分配的基本单位.进程是线程的容器.

线程: 是操作系统能够进行运算调度的最小单位,包含在进程中.

进程:系统资源分配的基本单位
线程:系统进行运算调度的最小单位

总结:
1:一个进程最起码有一个线程
2:线程之间资源贡献,线程通讯(线程间内存共享)

总结:CPU调度进程之前要准备数据 如开辟的内存,外部资源 以及运行过程中产生的一些变量和临时存储.这些和进程关联的东西称之为进程上下文.

1:线程和进程的区别?
进程是一个程序或者一个应用,线程是进程中的一个任务.进程是线程的容器.

线程方法说明:
1:thread.sleep(long):强制线程睡眠一段时间。
2:thread.start():启动一个线程。
3:thread.join():在当前线程中加入指定线程,使得这个指定线程等待当前线程,并在当前线程结束前结束。
4:thread.yield():使得当前线程退让出CPU资源,把CPU调度机会分配给同样线程优先级的线程
5:thread.interrupt():使得指定线程中断阻塞状态,并将阻塞标志位置为true。(只改变了状态 不中断执行)
6:object.wait()、object.notify()、object.notifyAll():Object类提供的线程等待和线程唤醒方法。

注意线程状态
1.Thread.State NEW 新建状态 : 尚未启动的线程的线程状态。Thread thread= new Thread()

2.Thread.State  RUNNABLE  就绪可运行状态

  1:就绪,可运行状态
    1:线程创建后开启线程又可以分为准备状态和运行状态
    2:就绪状态只是说你资格运行,调度程序没有挑选到你,你就永远是就绪状态。
    3:调用线程的start()方法,此线程进入就绪状态。
    4:当前线程sleep()方法结束,其他线程join()结束,等待用户输入完毕,某个线程拿到对象锁,这些线程也将进入就绪状态。
    5:当前线程时间片用完了,调用当前线程的yield()方法,当前线程进入就绪状态。
    6:锁池里的线程拿到对象锁后,进入就绪状态。
  2:当CPU调度到了此线程且此线程是就绪状态  CPU调度后就是 执行状态了
  
3.Thread.State BLOCKED 阻塞状态  阻塞状态是线程阻塞在进入synchronized关键字修饰的方法或代码块(获取锁)时的状态。

    线程调用synchronized 修饰的方法或者代码块  此方法在等待获取锁的时候线程 属于阻塞状态

4. Thread.State WAITING 等待状态  处于这种状态的线程不会被CPU调度 需要被显示的唤醒 否则会一直等待下去  
    唤醒:
        1:object.wait()、object.notify()、object.notifyAll()唤醒;
        2:其他线程join()导致的等待状态需要等待另外线程结束.
        


5: Thread.State TIMED_WAITING 倒计时等待状态 于这种状态的线程不会被分配CPU执行时间,不过无须无限期等待被其他线程显示地唤醒,在达到一定时间后它们会自动唤醒。
    成线程限时等待状态的原因有五种:
        Thread.sleep(long)
        Object.wait(long)
        join(long)
        LockSupport.parkNanos(obj,long)
        LockSupport.parkUntil(obj,long)

6: Thread.State TERMINATED  结束状态 一个完全运行完成的线程的状态。也称之为终止状态、结束状态。


注意:
object.wait()   join()  方法中加时间进入TIME_WAITING状态 不加时间进入WAITING状态
Thread.sleep(long)

2:线程实现.

new Thread 实现Runable接口 调用start开启线程.

继承Thread 实现Runable接口 调用start开启线程.

3:Thread run和start区别.

run:方式只是Runable接口的普通方法
start方法:开启线程

sleep 方法和 wait 方法有什么区别
sleep 是Thread的方法 wait 是Object 的方法

sleep 定时器 结束后会执行
wait 需要唤醒才执行
obj.wait(100)

1:等待
wait sleep synchronized
2:顺序
join

3:中断
只能中断状态 需要搭配 while(true) 判断状态

4:插入
join

public class ThreadUtil {

public  static void  start(){
    Thread thread=   new Thread();
    System.out.println("状态:"+thread.getState());
    thread.start();
    System.out.println("状态:"+thread.getState());
}


public  static void  join(){
    Thread thread=   new Thread(){
        @Override
        public void run() {
            super.run();
            try {
                Thread.sleep(2000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println("thread1状态:"+"执行结束");
        }
    };
    System.out.println("thread1状态:"+thread.getState());
    thread.start();
    System.out.println("thread1状态:"+thread.getState());


    Thread thread2=   new Thread(){
        @Override
        public void run() {
            super.run();

            System.out.println("thread2状态:"+"执行结束");
        }
    };
    System.out.println("thread2:"+thread2.getState());
    thread2.start();
    System.out.println("thread2:"+thread2.getState());
    try {
        thread2.join();
    } catch (InterruptedException e) {
        e.printStackTrace();
    }

}

/**
 * 线程顺序执行
 */
public  static void  orderJoin(){

    Thread thread=   new Thread(){
        @Override
        public void run() {
            super.run();
            try {

                Thread.sleep(2000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println("thread1--->执行");
        }
    };

    Thread thread2=   new Thread(){
        @Override
        public void run() {
            super.run();
            try {
                Thread.sleep(5000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println("thread2--->执行");
        }
    };

    Thread thread3=   new Thread(){
        @Override
        public void run() {
            super.run();
            System.out.println("thread3--->执行");
        }
    };

    try {
        thread.start();
        thread.join();

        thread2.start();
        thread2.join();

        thread3.start();
        thread3.join();

    } catch (InterruptedException e) {
        e.printStackTrace();
    }

}
public static void  yield(){
    Thread thread=   new Thread(){
        @Override
        public void run() {
            super.run();
            try {
                Thread.sleep(5000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println("thread1---> 结束");
        }
    };

    Thread thread2=   new Thread(){
        @Override
        public void run() {
            super.run();
            System.out.println("thread2---> 结束");
        }
    };
    System.out.println("thread1状态:"+thread.getState());
    thread.start();
    System.out.println("thread1状态:"+thread.getState());
    Thread.yield();
    thread2.start();
    System.out.println("thread2状态:"+thread.getState());

}

}

©著作权归作者所有,转载或内容合作请联系作者
平台声明:文章内容(如有图片或视频亦包括在内)由作者上传并发布,文章内容仅代表作者本人观点,简书系信息发布平台,仅提供信息存储服务。

推荐阅读更多精彩内容

  • 前言 操作系统中,一个进程往往代表着一个应用程序实例,而线程是进程中轻量级的调度单元,也可以看作是轻量级的进程,可...
    小波同学阅读 590评论 0 2
  • 进程:是系统进行内存分配的基本单位,是计算机进行数据处理的一次活动,进程是线程的容器. 线程:是操作系统进行运算调...
    没有了遇见阅读 226评论 0 2
  • 本文出自 Eddy Wiki ,转载请注明出处:http://eddy.wiki/interview-java.h...
    eddy_wiki阅读 2,250评论 0 14
  • 面试专题我放在git上了,地址Github 欢迎fork然后一起更新 Java基础点 0,面对对象OOP和面对过程...
    hloong阅读 832评论 0 3
  • 终于在耽搁了几天之后,开始看关于线程的面试题了。之前被腾讯大佬问过,这一块得好好补补。 1.什么是线程,什么是进程...
    Y_丫咪阅读 707评论 0 0