线程 interrupt() ,join()，synchronized()的基本用法

线程优先级：
    优先级用整数表示，取值范围1~10,一般情况下，线程的默认优先级都是5，
    但是也可以通过setPriority和getPriority方法来设置，获取返回优先级。
    
============================================================    
两种线程的实现方法中的优先级
public class ThreadDemo1 {

    public static void main(String[] args) {
        MyThread2 my=new MyThread2();
        Thread t=new Thread(my);
        //设置最小优先级
        t.setPriority(Thread.MIN_PRIORITY);
        t.start();
        
        MyThread01 my1=new MyThread01();
        //设置最大优先级
        my1.setPriority(Thread.MAX_PRIORITY);
        my1.start();
    }
}
class MyThread2 implements Runnable{

    public void run() {
        for (int i = 0; i < 100; i++) {
            System.out.println("a");
        }
    }
}
class MyThread01 extends Thread{

    public void run() {
        for (int i = 0; i < 100; i++) {
            System.out.println("b");
        }
    }
}
======================================================
线程中断案例
public class ThreadDemo3 {

    public static void main(String[] args) {
        MyThread05 my=new MyThread05();
        Thread t=new Thread(my);
        t.start();
        System.out.println("\n线程："+t.isAlive());
        
        try {
            Thread.sleep(2000);
            t.interrupt();//中断线程
        } catch (InterruptedException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }
        System.out.println("\n线程："+t.isAlive());
    }

}
class MyThread05 implements Runnable{

    public void run() {
        for (int i = 0; i < 100; i++) {
            try {
                Thread.sleep(100);
                System.out.println("休眠正常结束。。。。。");
            } catch (InterruptedException e) {
                System.out.println("线程被中断了。。。。。");
                break;
            }
            System.out.print(i+"a");
        }
    }
}
================================================================
线程加入案例
public class ThreadDemo4 {

    public static void main(String[] args) {
        MyThread06 my=new MyThread06();
        Thread t=new Thread(my);
        //t.setPriority(Thread.MIN_PRIORITY);
        
        t.start();
        
        MyThread07 my1=new MyThread07(t);
        //设置优先级
        my1.setPriority(Thread.MAX_PRIORITY);
        my1.start();
        for (int i = 0; i < 100; i++) {
            if(i==10){
                try {
                    t.join();//加入线程,当前线程等待t线程终止，再执行
                } catch (InterruptedException e) {
                    // TODO Auto-generated catch block
                    e.printStackTrace();
                }
            }
            try {
                Thread.sleep(100);
            } catch (InterruptedException e) {
                // TODO Auto-generated catch block
                e.printStackTrace();
            }
            System.out.print("c");
        }
    }
}
class MyThread06 implements Runnable{

    public void run() {
        for (int i = 0; i < 100; i++) {
            try {
                Thread.sleep(100);
            } catch (InterruptedException e) {
                // TODO Auto-generated catch block
                e.printStackTrace();
            }
            System.out.print("a");
        }
    }
}
class MyThread07 extends Thread{
    Thread t;
    public MyThread07(Thread t){
        this.t=t;
    }
    public void run() {
        for (int i = 0; i < 100; i++) {
            if(i==10){
                try {
                    t.join();
                } catch (InterruptedException e) {
                    // TODO Auto-generated catch block
                    e.printStackTrace();
                }
            }
            try {
                Thread.sleep(100);
            } catch (InterruptedException e) {
                // TODO Auto-generated catch block
                e.printStackTrace();
            }
            System.out.print("b");
        }
    }
}
===================================================================
//线程的生命周期
        //1.创建
        //2.start()就绪，抢夺CPU资源
        //3.运行
        // 4.阻塞状态
        //5.结束
public class ThreadDemo5 {

    public static void main(String[] args) {
        MyThread08 my=new MyThread08(Thread.currentThread());
        Thread t=new Thread(my);
        t.start();
        System.out.println("b");
        //线程的生命周期
        //1.创建
        //2.start()就绪，抢夺CPU资源
        //3.运行
        // 4.阻塞状态
        //5.结束
        for (int i = 0; i < 10; i++) {
            try {
                Thread.sleep(100);
            } catch (InterruptedException e) {
                // TODO Auto-generated catch block
                e.printStackTrace();
            }
            System.out.print("b");
        }
        
    }
}
class MyThread08 implements Runnable{
    public Thread t;
    public MyThread08(Thread t){
        this.t=t;
    }
    public void run() {
        for (int i = 0; i < 10; i++) {
            if(i==5){
                try {
                    t.join();
                } catch (InterruptedException e) {
                    // TODO Auto-generated catch block
                    e.printStackTrace();
                }
            }
            try {
                Thread.sleep(100);
            } catch (InterruptedException e) {
                // TODO Auto-generated catch block
                e.printStackTrace();
            }
            System.out.print("a");
        }
    }
}
=======================================================================
线程的同步
public class ThreadDemo6 {

    public static void main(String[] args) {
        Data d=new Data();
        MyThread010 my=new MyThread010(d);
        MyThread010 my1=new MyThread010(d);
        my.start();
        my1.start();
        
        //同步处理
        //1.同步方法
            
        //2.同步块
    }

}
class MyThread010 extends Thread{
    private Data data;
    //实现数据共享
    public MyThread010(Data data){
        this.data=data;
    }
//    public void run() {
//        for (int i = 0; i < 10; i++) {
//            data.setNum(data.getNum()+1);
//            System.out.println(getName()+"=="+data.getNum()+"begin....");
//            try {
//                Thread.sleep(100);
//            } catch (InterruptedException e) {
//                // TODO Auto-generated catch block
//                e.printStackTrace();
//            }
//            System.out.println(getName()+"=="+data.getNum()+"begin....");
//        }
//        
//    }
    public void run(){
        synMethod();
    }
    public synchronized void synMethod(){
        for (int i = 0; i < 10; i++) {
            data.setNum(data.getNum()+1);
            System.out.println(getName()+"=="+data.getNum()+"====begin....");
            System.out.println(getName()+"=="+data.getNum()+"====end....");
        }
    }
    /*
    public void synMethod(){
        synchronized(this){
            for (int i = 0; i < 10; i++) {
                data.setNum(data.getNum()+1);
                System.out.println(getName()+"=="+data.getNum()+"begin....");
                System.out.println(getName()+"=="+data.getNum()+"end....");
            }
        }
    }
    */
    
    
}
class Data{
    private int num;

    public int getNum() {
        return num;
    }

    public void setNum(int num) {
        this.num = num;
    }
    
}