java-Thread学习

Thread是进程中的实际运作单位。一条线程指的是进程中一个单一顺序的控制流，一个进程中可以并发多个线程，每条线程并行执行不同的任务，一个进程的所有线程共享它的虚拟地址空间、全局变量和操作系统资源。

优点：
(1) 创建线程的同时可以继承其他的类，从而可以扩展类的功能。
(2) 实现Runnable接口的实例可以作为多个Thread的target,这样可以实现资源的共享
(3) 由于创建新进程必须加载代码，而线程要执行的代码已经被映射到进程的地址空间，所以创建、执行线程的速度比进程更快。

缺点：
(1) 由于java的继承机制是单一继承，继承Thread类就不能继承其他的类。
(2) 使用new Thread的创建方式占用过多系统资源，可能循环被创建，造成损耗。

Thread源码注释：

• A {@code Thread} is a concurrent unit of execution. It has its own call stack
• for methods being invoked, their arguments and local variables. Each application
• has at least one thread running when it is started, the main thread, in the main
• {@link ThreadGroup}. The runtime keeps its own threads in the system thread
• group.
• <p>There are two ways to execute code in a new thread.
• You can either subclass {@code Thread} and overriding its {@link #run()} method,
• or construct a new {@code Thread} and pass a {@link Runnable} to the constructor.
• In either case, the {@link #start()} method must be called to actually execute
• the new {@code Thread}.
• <p>Each {@code Thread} has an integer priority that affect how the thread is
• scheduled by the OS. A new thread inherits the priority of its parent.
• A thread's priority can be set using the {@link #setPriority(int)} method.

1.thread是一个并发执行单位，他有自己的调用堆栈，在一个主线程中，至少有一个线程运行，系统中保持自己的线程的线程组
2.有2种开启线程的方法，可以继承Thread实现run方法，或实现Runnable接口，或new一个Runnable对象，必须调用start方法
3.每个线程都有一个优先级，一个新线程继承他父类的优先级，可以设置优先级。

优先级的说明
public static final int MAX_PRIORITY = 10; 最大优先级
public static final int MIN_PRIORITY = 1; 最小优先级
public static final int NORM_PRIORITY = 5; 默认优先级

线程状态的说明（getState()获取）
NEW:刚创建还没启动
RUNNABLE:可以执行，start()
BLOCKED:堵塞状态，等待持有锁
WAITING : 处理等待状态 ，Object.wait()或Thread.join()而未运行
TIMED_WAITING:等待一些时间，Thread.sleep()
TERMINATED:终止，run方法结束

构造方法
private void create(ThreadGroup group, Runnable runnable, String threadName, long stackSize){}

ThreadGroup :线程组，管理线程用，getThreadGroup()取得当前线程所在组，getName()：取得组的名称，等
setDaemon 设置守护线程，当前运行的都是守护线程时java虚拟机退出，优先级低。
setMaxPriority 设置线程组的最高优先级
Runnable 调用接口run来实现
threadName 线程名字 this.name = "Thread-" + id;
stackSize 堆栈大小

举例看看线程的一些特性

    Thread thread1 = new Thread(new MyThread(1));
    Thread thread2 = new Thread(new MyThread(2));

// thread1.setPriority(Thread.MIN_PRIORITY);
// thread2.setPriority(Thread.MAX_PRIORITY);
thread1.start();
// try {
// thread1.join();
// } catch (InterruptedException e) {
// e.printStackTrace();
// }
thread2.start();
}

class MyThread implements Runnable {
    int id;
    public MyThread(int id) {
        this.id = id;
    }
    public void run() {
        for (int i = 1; i <= 5; i++) {
            Log.d("wuc","Thread" + id + "执行了方法i = " + i + " 活动的线程数" + Thread.activeCount() );
        }
    }
}

Thread1执行了方法i = 1 活动的线程数3
Thread1执行了方法i = 2 活动的线程数3
Thread1执行了方法i = 3 活动的线程数3
Thread2执行了方法i = 1 活动的线程数3
Thread2执行了方法i = 2 活动的线程数3
Thread1执行了方法i = 4 活动的线程数2
Thread2执行了方法i = 3 活动的线程数2
Thread1执行了方法i = 5 活动的线程数2
Thread2执行了方法i = 4 活动的线程数2
Thread2执行了方法i = 5 活动的线程数2
结果可以看出两个Thread同时访问一个资源是交错执行的

放开注释下面2行注释(设置优先级)
// thread1.setPriority(Thread.MIN_PRIORITY);
// thread2.setPriority(Thread.MAX_PRIORITY);

Thread2执行了方法i = 1 活动的线程数3
Thread2执行了方法i = 2 活动的线程数3
Thread2执行了方法i = 3 活动的线程数3
Thread2执行了方法i = 4 活动的线程数3
Thread2执行了方法i = 5 活动的线程数3
Thread1执行了方法i = 1 活动的线程数2
Thread1执行了方法i = 2 活动的线程数2
Thread1执行了方法i = 3 活动的线程数2
Thread1执行了方法i = 4 活动的线程数2
Thread1执行了方法i = 5 活动的线程数2
结果看出优先级高的先执行

再放开注释
// try {
// thread1.join();
// } catch (InterruptedException e) {
// e.printStackTrace();
// }

Thread1执行了方法i = 1 活动的线程数1
Thread1执行了方法i = 2 活动的线程数1
Thread1执行了方法i = 3 活动的线程数1
Thread1执行了方法i = 4 活动的线程数1
Thread1执行了方法i = 5 活动的线程数1
Thread2执行了方法i = 1 活动的线程数1
Thread2执行了方法i = 2 活动的线程数1
Thread2执行了方法i = 3 活动的线程数1
Thread2执行了方法i = 4 活动的线程数1
Thread2执行了方法i = 5 活动的线程数1
结果是Thread2.join()后 等待其他线程执行完毕后再执行thread2的方法

还有很多问题不是很明白???

1.这些状态参数是做什么的
NANOS_PER_MILLI = 100000 大约16分钟
class ParkState{
UNPARKED = 1
PREEMPTIVELY_UNPARKED = 2
PARKED = 3
}

2.create 里面设置setDaemon守护进程在哪些地方用

3.举例中为什么执行join()方法活动线程一直只有1个

4.如果在例子中加一个sleep的方法让Thread睡一会，运行结果每次都不一样。