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());

}

}