Java线程

 

 线程使用：

public class Thread01 {
    public static void main(String[] args) {
        //创建Cat对象可以当成一个线程使用
        Cat cat = new Cat();
        cat.start();//启动线程
    }
}

//当一个类继承了Thread类，该类就是一个线程类
//重写run方法，写上自己的业务代码
//run Thread 类实现了Runnable接口方法
class Cat extends Thread{
    int times=0;
    @Override
    public void run() {
        super.run();
        while (true){
            System.out.println("你好！"+(++times));
        //让该线程休眠1秒
        try {
            Thread.sleep(1000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        if (times ==8){
            break;
            }
        }
    }
}

使用接口创建多线程：

public class Thread01 {
    public static void main(String[] args) throws InterruptedException {
        //创建Cat对象可以当成一个线程使用
        Cat cat = new Cat();
        Dog dog = new Dog();
        //不能使用start方法
        //cat.start();//启动线程
        //代理模式
        Thread thread = new Thread(cat);
        Thread thread1 = new Thread(dog);
        thread.start();
        thread1.start();
    }
}

//当一个类继承了Thread类，该类就是一个线程类
//重写run方法，写上自己的业务代码
//run Thread 类实现了Runnable接口方法
class A{};
class Cat  implements Runnable{
    int times=0;
    @Override
    public void run() {
        while (true){
            System.out.println("cat！"+(++times)+Thread.currentThread().getName());
        //让该线程休眠1秒
        try {
            Thread.sleep(2000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        if (times ==8){
            break;
            }
        }
    }
}
class Dog  implements Runnable{
    int times=0;
    @Override
    public void run() {
        while (true){
            System.out.println("dog！"+(++times)+Thread.currentThread().getName());
            //让该线程休眠1秒
            try {
                Thread.sleep(2000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            if (times ==8){
                break;
            }
        }
    }
}

通知线程停止：

public class Thread01 {
    public static void main(String[] args) throws InterruptedException {
        //创建Cat对象可以当成一个线程使用
        Cat cat = new Cat();
        //不能使用start方法
        //cat.start();//启动线程
        //代理模式
        cat.start();
        Thread.sleep(10000);
        cat.setLoop(false);
    }
}

//当一个类继承了Thread类，该类就是一个线程类
//重写run方法，写上自己的业务代码
//run Thread 类实现了Runnable接口方法
class Cat  extends Thread{
    private Boolean loop = true;
    int times=0;
    @Override
    public void run() {
        while (loop){
            System.out.println("cat！"+(++times)+Thread.currentThread().getName());
        //让该线程休眠1秒
        try {
            Thread.sleep(60);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        }
    }

    public Boolean getLoop() {
        return loop;
    }

    public void setLoop(Boolean loop) {
        this.loop = loop;
    }
}

 

public class Thread01 {
    public static void main(String[] args) throws InterruptedException {
        T t = new T();
        t.setName("mqs");
        t.setPriority(Thread.MIN_PRIORITY);
        t.start();

        for (int i=1;i<10;i++){
            System.out.println("主程序打印："+i);
        }
        t.interrupt();
    }
}

//当一个类继承了Thread类，该类就是一个线程类
//重写run方法，写上自己的业务代码
//run Thread 类实现了Runnable接口方法
class T extends Thread{
    @Override
    public void run() {
        super.run();
        while (true) {
            for (int i = 0; i < 10; i++) {
                System.out.println(Thread.currentThread().getName() + "执行线程");
            }
            System.out.println(Thread.currentThread().getName() + "休眠中：休眠20秒");
            try {
                Thread.sleep(10000);//20秒
            } catch (InterruptedException e) {
                //当该线程执行到一个interrupt方法时额，就会catch一个异常，可以加入自己的业务代码
                System.out.println(Thread.currentThread().getName() + "interrupt");
            }
        }
    }
}

 

package o2;

public class Thread01 {
    public static void main(String[] args) throws InterruptedException {
        T t = new T();
       // M m = new M();
        t.start();
        //m.start();
       for (int i=0; i<20; i++){
           Thread.sleep(1000);
            System.out.println(Thread.currentThread().getName() +"线程main");
            if (i==5){
                //t.join();//插队
                Thread.yield();
            }
        }
    }
}

//当一个类继承了Thread类，该类就是一个线程类
//重写run方法，写上自己的业务代码
//run Thread 类实现了Runnable接口方法
class T extends Thread{
    @Override
    public void run() {
        for (int i=1; i<20; i++) {
            try {
                Thread.sleep(1000);
                System.out.println(Thread.currentThread().getName() + "线程T");
            } catch (Exception e) {
                e.printStackTrace();
            }
        }
    }
}

class M extends Thread{
    @Override
    public void run() {
        super.run();
            for (int i = 0; i < 20; i++) {
                try {
                    Thread.sleep(1000);
                    System.out.println(Thread.currentThread().getName() + "线程M");
                } catch (InterruptedException e) {
                    //当该线程执行到一个interrupt方法时额，就会catch一个异常，可以加入自己的业务代码
                    System.out.println(Thread.currentThread().getName() + "interrupt");
                }
            }

    }
}

 守护线程：

public class Thread01 {
    public static void main(String[] args) throws InterruptedException {
        MyDaemonThread myDaemonThread = new MyDaemonThread();
        Thread thread1 = new Thread(myDaemonThread);
        thread1.setDaemon(true);
        thread1.start();
        for (int i=0; i<=10; i++){
            System.out.println("主线程");
            Thread.sleep(1000);
        }
    }
}

//当一个类继承了Thread类，该类就是一个线程类
//重写run方法，写上自己的业务代码
//run Thread 类实现了Runnable接口方法
class MyDaemonThread implements Runnable {

    @Override
    public void run() {
        while (true) {
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println("子线程");
        }
    }
}

线程同步机制：

 

 

 

 互斥锁：

 

 

public class Thread01 {
    public static void main(String[] args) throws InterruptedException {
        T t1= new T();
        T t2= new T();
        new Thread(t1).start();
        new Thread(t1).start();
        new Thread(t1).start();
    }
}

//当一个类继承了Thread类，该类就是一个线程类
//重写run方法，写上自己的业务代码
//run Thread 类实现了Runnable接口方法
class T implements Runnable {
    private int tickeNum=100;
    boolean loop = true;
    Object object = new Object();

    // public synchronized static void m1()锁是加在T.class
    public synchronized static void m1(){

    }

    public static void m2(){
        synchronized (/*不能是this*/ T.class) {
            System.out.println("m2");
        }
    }


    public  void sell() {
        //可以是其他对象
        synchronized (/*this*/ object) {
            if (tickeNum <= 0) {
                System.out.println("以售票完！");
                loop = false;
                return;
            }

            try {
                Thread.sleep(1);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println(Thread.currentThread().getName() + "还剩余：" + (--tickeNum) + "票");
        }
    }

    @Override
    public void run() {
        while (loop) {
            sell();
        }
    }
}
class M extends Thread {
    private int tickeNum=100;
    boolean loop = true;

    public  void sell() {
        synchronized (this) {
            if (tickeNum <= 0) {
                System.out.println("以售票完！");
                loop = false;
                return;
            }

            try {
                Thread.sleep(100);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println(Thread.currentThread().getName() + "还剩余：" + (--tickeNum) + "票");
        }
    }
    @Override
    public void run() {
        super.run();
        while (loop) {
            sell();
        }
    }
}

线程死锁原理：

public class Thread01 {
    public static void main(String[] args) throws InterruptedException {
        DeadLockDemo deadLockDemo = new DeadLockDemo(true);
        DeadLockDemo deadLockDemo1 = new DeadLockDemo(false);
        Thread thread = new Thread(deadLockDemo);
        Thread thread1 = new Thread(deadLockDemo1);
        thread.start();
        thread1.start();
    }
}
//当一个类继承了Thread类，该类就是一个线程类
//重写run方法，写上自己的业务代码
//run Thread 类实现了Runnable接口方法
class DeadLockDemo implements Runnable {
    static Object o1 = new Object();
    static Object o2 = new Object();
    boolean flag;

    public DeadLockDemo(boolean flag) {
        this.flag = flag;
    }

    @Override
    public void run() {
        //死锁产生业务逻辑分析
        //如果flag为T线程A就会先得到持有o1对象锁，然后尝试去获取o2对象锁
        //如果线程A得不到o2对象所，就会Blocked
        //如果flag为F，线程B就会先得到持有对象锁，然后尝试去获取o1对象锁
        //如果线程B得不到o1对象锁，就会Blocked
        if (flag){
            synchronized (o1){
                System.out.println(Thread.currentThread().getName()+"进入1");
                synchronized (o2){
                    System.out.println(Thread.currentThread().getName()+"进入2");
                }
            }
        }else {
            synchronized (o2){
                System.out.println(Thread.currentThread().getName()+"进入3");
                synchronized (o1){
                    System.out.println(Thread.currentThread().getName()+"进入4");
                }
            }
        }

    }
}

释放锁：

 线程练习：

public class Thread01 {
    public static void main(String[] args) throws InterruptedException {
        A a = new A();
        B b = new B(a);//必须要线程接收A的对象
        Thread thread = new Thread(a);
        thread.start();
        Thread thread1 = new Thread(b);
        thread1.start();
    }
}
//当一个类继承了Thread类，该类就是一个线程类
//重写run方法，写上自己的业务代码
//run Thread 类实现了Runnable接口方法
class A implements Runnable {
    private boolean flag = true;

    public void setFlag(boolean flag) {
        this.flag = flag;
    }

    @Override
    public void run() {
        while (flag){
            int v = (int)(Math.random() * 100 + 1);
            System.out.println(v);
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }
}

class B implements Runnable{
    private A a;
    private Scanner scanner = new Scanner(System.in);
    public B(A a) {
        this.a = a;
    }

    @Override
    public void run() {
        while (true) {
            System.out.println("请输入指令:");
            char key = scanner.next().toUpperCase(Locale.ROOT).charAt(0);
            if (key == 'Q') {
                a.setFlag(false);
                break;
            }
        }
    }
}