import java.util.Date;
public class TestThread {
/**
* Thread 和 runnable区别: Thread 中继承该类的子类只能启动一个 start方法,开启一个线程 ,而实现
* runnable接口的子类可以开启多个线程,访问同一个类的资源
*/
public static void main(String[] args) {
Thread1 ts = new Thread1();
ts.start();
Thread2 ts2=new Thread2();
new Thread(ts2).start();
new Thread(ts2).start();
}
}
//Thread.yield();//暂停当前正在执行的线程对象，并执行其他线程。 每次执行都是短暂的暂停 然后之后自动恢复
class Thread1 extends Thread {
@Override
public void run() {
for (int i = 0; i < 100; i++) {
System.out.println(Thread.currentThread().toString()+"----"+i);
Thread.yield();//暂停当前正在执行的线程对象，并执行其他线程。
}
}
}
class Thread2 implements Runnable {
@Override
public void run() {
for (int i = 0; i < 100; i++) {
System.out.println(Thread.currentThread().toString()+"--"+i);
//Thread.yield();//暂停当前正在执行的线程对象，并执行其他线程。
}
}
}
class YieldDemo extends Thread {
public YieldDemo(String name) {
super(name);
}
public void run() {
for (int i = 0; i < 1000; i++) {
System.out.println(this.getName() + ":" + i);
if (i % 10 == 0) {
this.yield();
}
}
}
}
/**
* 测试 interruput interruput 是把冻结状态中(sleep,wait,join )的线程唤醒
*
*
*/
class InterruptDemo implements Runnable {
boolean flag = true;// 线程停止的 标记
public synchronized void run() {
while (flag) {
System.out.println(Thread.currentThread().getName() + "=="
+ new Date() + "==");
try {
System.out.println(Thread.currentThread().getName() + "wait");
this.wait();
// Thread.sleep(10);
} catch (InterruptedException e) {
e.printStackTrace();
flag = false; // 线程被异常中断时就停止线程
}
}
}
public static void main(String[] args) {
InterruptDemo t = new InterruptDemo();
Thread t1 = new Thread(t);
t1.start();
Thread t2 = new Thread(t);
t2.start();
try {
Thread.sleep(10000);
} catch (Exception e) {
}
t1.interrupt();
t2.interrupt();
}
}
/**
* 守护线程(后台线程) ,需要在执行start 方法前调用 与普通线程的区别是 :当正在运行的线程都是守护线程时，Java 虚拟机退出(系统结束)。 本例中
* 两个线程都是 守护线程 当主线程结束时两个守护线程同时结束
*
*/
class Daemon implements Runnable {
boolean flag = true;// 线程停止的 标记
public void run() {
while (flag) {
System.out.println(Thread.currentThread().getName() + "=="
+ new Date() + "==");
}
}
public static void main(String[] args) {
Daemon t = new Daemon();
Thread t1 = new Thread(t);
t1.setDaemon(true);
t1.start();
Thread t2 = new Thread(t);
t2.setDaemon(true);
t2.start();
try {
Thread.sleep(5000);
} catch (Exception e) {
e.printStackTrace();
}
System.out.println("main Thread over");
}
}
/**
* join 等待该线程终止。将这个线程合并到主线程上 这个线程执行完才会执行主线程 另一种情况 如果 线程 A执行到了 线程 B 的 join
* 方法,A就会等待 直到B执行万才会继续执行
*/
class JoinDemo implements Runnable {
public static void main(String[] args) throws InterruptedException {
JoinDemo jd = new JoinDemo();
Thread t1 = new Thread(jd);
Thread t2 = new Thread(jd);
t1.start();
// t1.join(); //放在这里 执行的顺序是 t1 全部执行完 主线程和t2抢夺执行权交替执行
t2.start();
t1.join();// 放在这里 执行顺序 是 t1 和t2 抢夺执行权 但是 只有当 t1全部执行完毕 main 才可以执行
for (int i = 0; i < 100; i++) {
Thread.sleep(10);
System.out.println("the main thread------");
}
}
@Override
public void run() {
for (int i = 0; i < 50; i++) {
try {
Thread.sleep(10);
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println(Thread.currentThread().getName() + "--" + i);
}
}
}
/**
* wait 使放弃执行和锁(API 中叫 监视器)的所有权,需要 notify ,notifyAll 唤醒 在 一个 同步中如果 当前线程 wait
* 别的线程可以进入这个 同步中 sleep 是当前线程放弃执行权但不放弃锁(API 中叫 监视器)的所有权, 在 一个 同步中如果 当前线程 sleep
* 别的线程不可以进入这个 同步中
*
*
* 同步的前提: 必须有两个或两个以上的线程 必须是多个线程使用同一个锁 必须保证同步中同以时间只有一个线程在运行
*
*/
class TestWait implements Runnable {
int no = 100;
@Override
public void run() {
// synchronized (this) {
while (true) {
if (no > 0) {
System.out
.println(no + "--" + Thread.currentThread().getName());
no--;
notify();
try {
System.out.println(Thread.currentThread().getName()
+ "--wait");
wait();
System.out.println(Thread.currentThread().getName()
+ "--weakup ");
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
}
public static void main(String[] args) {
TestWait t1 = new TestWait();
new Thread(t1).start();
new Thread(t1).start();
new Thread(t1).start();
new Thread(t1).start();
}
}
/**
* 测试死锁
*/
public class TestDeadLock implements Runnable{
public int flag=1;
static Object o1 =new Object();
static Object o2 = new Object();
public static void main(String[] args) {
TestDeadLock td=new TestDeadLock();
td.flag=1;
TestDeadLock td1= new TestDeadLock();
td.flag=0;
Thread t = new Thread(td);
Thread t1 = new Thread(td1);
t.start();
t1.start();
}
@Override
public void run() {
if(flag==1 ){
synchronized(o1){
try {
Thread.sleep(100);
} catch (InterruptedException e) {
e.printStackTrace();
}
synchronized(o2){
System.out.println("1");
}
}
}
if(flag==0 ){
synchronized(o2){
try {
Thread.sleep(100);
} catch (InterruptedException e) {
e.printStackTrace();
}
synchronized(o1){
System.out.println("0");
}
}
}
}
}