Java 多线程编程核心技术

One is to declare a class to be a subclass(子类) of Thread. This subclass should override the run method of class Thread. An instance of the subclass
can then be allocated and started. For example, a thread that computes primeslarger  than a stated value could be written as follows:
//继承 Thread 类
class PrimeThread extends Thread {
long minPrime;
PrimeThread(long minPrime) {
this.minPrime = minPrime;
}

//重写 Thread 类的 run 方法

The other way to create a thread is to declare a class that implements the Runnable interface. That class then implements the run method.
An instance of the class can then be allocated, passed as an argument when creating Thread, and started. The same example in this other style looks like
the following:
//实现 Runnable 接口
class PrimeRun implements Runnable {
long minPrime;
PrimeRun(long minPrime) {
this.minPrime = minPrime;
}

//重写 run 方法

//测试当前线程是否已经中断了，这个线程的中断状态会被这个方法清除。
//换句话说，如果连续两次调用了这个方法，第二次调用的时候将会返回 false
public static boolean interrupted() {
return currentThread().isInterrupted(true);
}

//测试线程是否已经中断了，线程的状态不会受这个方法的影响
//线程中断被忽略，因为线程处于中断下不处于活动状态的线程由此返回false的方法反映出来
public boolean isInterrupted() {
return isInterrupted(false);
}
/*** Tests if some Thread has been interrupted. The interrupted state* is reset or not
based on the value of ClearInterrupted that is* passed.
*/private native boolean isInterrupted(boolean ClearInterrupted);

public class MyThread2 extends Thread{
@Overridepublic void run() {
try{
System.out.println("run start");
Thread.sleep(20000);
System.out.println("run end");
} catch (InterruptedException e) {
System.out.println("run catch "+this.isInterrupted());
e.printStackTrace();
}
}
public static void main(String[] args) {
try {
MyThread2 t2 = new MyThread2();
t2.start();
Thread.sleep(200);
t2.interrupt();
} catch (InterruptedException e) {
System.out.println("main catch");e.printStackTrace();
}
System.out.println("main end");
}
}

run startmain endrun catch falsejava.lang.InterruptedException:
sleep interrupted	at java.lang.Thread.sleep(Native Method)
at com.zhisheng.thread.thread1.MyThread2.run(MyThread2.java:12)

public class MyThread3 extends Thread{
@Overridepublic void run() {
try {
System.out.println("run start");
Thread.sleep(20000);
System.out.println("run end");
} catch (InterruptedException e) {
System.out.println("run catch "+this.isInterrupted());
e.printStackTrace();
}
}
public static void main(String[] args) {
MyThread3 t3 = new MyThread3();
t3.start();
t3.interrupt();
}
}

run startrun catch falsejava.lang.InterruptedException: sleep interrupted
at java.lang.Thread.sleep(Native Method)	at
com.zhisheng.thread.thread1.MyThread3.run(MyThread3.java:12)

public class MyThread4 extends Thread{
private int i;
public int getI() {
return i;
}
public void setI(int i) {
this.i = i;
}
@Overridepublic void run() {
while (true) {i++;}
}
public static void main(String[] args) throws InterruptedException {
MyThread4 t4 = new MyThread4();
t4.start();
System.out.println("A----- " + System.currentTimeMillis() + " ---- " + t4.getI());Thread.sleep(2000);System.out.println("A----- " + System.currentTimeMillis() + " ---- " +t4.getI());
t4.suspend();
Thread.sleep(2000);
t4.resume();
System.out.println("B----- " + System.currentTimeMillis() + " ---- " + t4.getI());Thread.sleep(2000);System.out.println("B----- " + System.currentTimeMillis() + " ---- " + t4.getI());}}

/***
A hint to the scheduler that the current thread is willing to yield*
its current use of a processor. The scheduler is free to ignore this*
hint.** <p> Yield is a heuristic attempt to improve relative
progression* between threads that would otherwise over-utilise a CPU.
Its use* should be combined with detailed profiling and benchmarking to*
ensure that it actually has the desired effect.** <p> It is
rarely appropriate to use this method. It may be useful* for debugging
or testing purposes, where it may help to reproduce* bugs due to race
conditions. It may also be useful when designing* concurrency control
constructs such as the ones in the* {@link java.util.concurrent.locks}
package.*/
//暂停当前正在执行的线程对象，并执行其他线程。暂停的时间不确定。
public static native void yield();

public class MyThread5 extends Thread{
@Overridepublic void run() {
double start = System.currentTimeMillis();
for (int i = 0; i < 200000; i++) {
//yield();
//暂停的时间不确定
i++;
}
double end = System.currentTimeMillis();
System.out.println("time is "+(end - start));}
public static void main(String[] args) {
MyThread5 t5 = new MyThread5();
t5.start();
}
}

public final void setPriority(int newPriority) {
ThreadGroup g;
checkAccess();
if (newPriority > MAX_PRIORITY || newPriority < MIN_PRIORITY) {
throw new IllegalArgumentException();
}
if((g = getThreadGroup()) != null) {
if (newPriority > g.getMaxPriority()) {
newPriority = g.getMaxPriority();
}
setPriority0(priority = newPriority);
}
}

/***
Marks this thread as either a {@linkplain #isDaemon daemon} thread* or a
user thread. The Java Virtual Machine exits when the only* threads
running are all daemon threads.** <p> This method must be invoked
before the thread is started.** @param on* if {@code true}, marks this
thread as a daemon thread* @throws IllegalThreadStateException* if this
thread is {@linkplain #isAlive alive}* @throws SecurityException* if
{@link #checkAccess} determines that the current* thread cannot modify
this thread*/public final void setDaemon(boolean on) {checkAccess();if
(isAlive()) {throw new IllegalThreadStateException();}daemon = on;}

class VarName{
private String userName = "A";
private String password = "AA";
synchronized public void setValue(String userName, String password) {
try {
this.userName = userName;
Thread.sleep(500);
this.password = password;
System.out.println("setValue method Thread name is : " + Thread.currentThread().getName() + " userName = " + userName + "password = " + password);
} catch (InterruptedException e) {
e.printStackTrace();
}
}
//synchronized
public void getValue() {
System.out.println("getValue method Thread name is : " + Thread.currentThread().getName() + " userName = " + userName + " password = " + password);
}
}
class Thread1 extends Thread{
private VarName varName;
public Thread1(VarName varName) {
this.varName = varName;
}
@Override
public void run() {
varName.setValue("B", "BB");
}
}
public class Test{
public static void main(String[] args) throws InterruptedException {
VarName v = new VarName();
Thread1 thread1 = new Thread1(v);
thread1.start();
Thread.sleep(200);
//打印结果受睡眠时间的影响v.getValue();
}
}

class
Service{synchronized public void service1()
{System.out.println("service 1");service2();}synchronized public void
service2() {System.out.println("service 2");service3();}synchronized
public void service3() {System.out.println("service 3");}}class Thread2
extends Thread{@Overridepublic void run() {Service s = new
Service();s.service1();}}public class Test2{public static void
main(String[] args) {Thread2 t2 = new Thread2();t2.start();}}

service 1service 2service 3