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.
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}.
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睡一会，运行结果每次都不一样。

java-Thread学习

你可能感兴趣的:(java-Thread学习)