Java进程（基础）

基本概念

1、进程：程序的执行过程

2、线程：一个进程可以有单个线程也就是我们说的单线程，还可以有多个线程也就是我们说的多线程，

线程

1、当一个类继承了Thread类就可以当成一个线程用

2、我们会重写run方法写上我们自己的业务逻辑

3、run Thread类实现了RUnnable接口,静态代理模式

创建一个线程为什么是start不是直接调用run方法，如果直接调用run方法并没有创建一个线程，而是串行执行，start方法中的start0方法创建一个线程是由本地方法，是由JVM调用的

当一个类他已经继承了其他类，但是我们还想让其作为线程使用的话就可以让其实现Runable接口

package threaduse;

public class Thread01 {
    public static void main(String[] args) {
        Cat cat = new Cat();
        //没有start方法
        //cat.start();
        Thread thread = new Thread(cat);
        thread.start();
    }
}
class Cat implements Runnable
{
    int cnt = 0;
    @Override
    public void run() {
        while(true)
        {
            System.out.println("小狗汪汪叫hi " + (++ cnt) + Thread.currentThread().getName());
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                throw new RuntimeException(e);
            }
            if(cnt == 10)   break;
        }
    }
}

多个子线程案例

package threaduse;

public class Thread03 {
    public static void main(String[] args) {
        T1 t1 = new T1();
        T2 t2 = new T2();
        Thread thread = new Thread(t1);
        Thread thread1 = new Thread(t2);
        thread1.start();
        thread.start();
    }

}

class T1 implements Runnable
{
    int cnt = 0;
    @Override
    public void run() {
        while(true)
        {
            System.out.println("hello world " + (++cnt));
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                throw new RuntimeException(e);
            }
            if(cnt == 10)   break;
        }
    }
}
class T2 implements Runnable
{
    int cnt = 0;
    @Override
    public void run() {
        while(true)
        {
            System.out.println("hi " + (++cnt));
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                throw new RuntimeException(e);
            }
            if(cnt == 10)   break;
        }
    }
}

模拟售票

package ticket;

//使用多线程模拟三个窗口同时售票
public class SellTicket {
    public static void main(String[] args) {
        SellTicket01 sellTicket01 = new SellTicket01();
        SellTicket01 sellTicket011 = new SellTicket01();
        SellTicket01 sellTicket012 = new SellTicket01();
        sellTicket012.start();
        sellTicket011.start();
        sellTicket01.start();
    }
}

//使用继承Thread
class SellTicket01 extends Thread
{
    private static int num = 100;
    @Override
    public void run() {
        while(true)
        {
            if(num <= 0)
            {
                System.out.println("售票结束...");
                break;
            }
            //休眠50ms
            try {
                Thread.sleep(50);
            } catch (InterruptedException e) {
            }
            System.out.println("窗口 " + Thread.currentThread().getName() +
                    "售出一张票" + "剩余票数 = " + (-- num));
        }
    }
}

出现问题

票重复卖

这里先提出问题后续会解决啦

通知线程退出

package exit_;

public class Thread_Exit {
    public static void main(String[] args) throws InterruptedException {
        T t = new T();
        t.start();
        //如果我们希望main线程去控制t线程的终止，必须可以修改loop->通知方式
        //休眠10s
        Thread.sleep(10 * 1000);
        t.setLoop(false);
    }
}

class T extends Thread
{
    int cnt = 0;

    //设置一个变量
    private boolean loop = true;
    @Override
    public void run() {
        while(loop)
        {
            try {
                Thread.sleep(50);
            } catch (InterruptedException e) {
                throw new RuntimeException(e);
            }
            System.out.println("T还在运行" + (++ cnt));
        }
    }

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

线程中断

线程的常用方法

1、start会调用run方法并且会创建一个新线程而单独调用run方法并不会创建新线程

2、interrupt，中断线程一般用于结束正在休眠的线程

3、sleep线程的休眠

3、现成的优先级

MAX、MIN、NORM

package Method;

import sun.awt.windows.ThemeReader;

public class ThreadMethod01 {
    public static void main(String[] args) throws InterruptedException {
        T t = new T();
        t.setName("阿杜");
        t.setPriority(Thread.MIN_PRIORITY);
        t.start();
        System.out.println(t.getName());
        //主线程打印5个hi，然后就中断子线程的休眠
        for(int i = 1; i <= 5; ++ i)
        {
            Thread.sleep(1000);
            System.out.println("hi" + i);
        }
        t.interrupt();
    }
}

//自定义的线程类
class T extends Thread
{
    @Override
    public void run() {
        while(true)
        {
            for(int i = 0; i < 100; ++ i)
            {
                //Thread.currentThread().getName()获取当前线程的名称
                System.out.println(Thread.currentThread().getName() + "吃包子~~~~~" + i);
            }
            try {
                System.out.println(Thread.currentThread().getName() + "休眠中~~~~~");
                Thread.sleep(5000);
            } catch (InterruptedException e) {
                //InterruptedException捕获到一个中断异常
                System.out.println(Thread.currentThread().getName() + "被 interrupt了");
            }
        }

    }
}

线程插队

yield：线程的礼让，让出cpu让其他线程先执行，让出的时间不确定，所以也不一定能成功让出

join：线程的插队，插队一旦成功，就一定会先执行完插队的进程

join方法调用的是对方的，也就是你想让插队的那个线程的

例题

package Method;

public class ThreadMethodExercise {
    public static void main(String[] args) throws InterruptedException {
        T3 t3 = new T3();
        Thread thread = new Thread(t3);
        for(int i = 1; i <= 10; ++ i)
        {
            System.out.println("hi " + i);
            if(i == 5)
            {
                thread.start();
                thread.join();
            }
        }
    }
}

class T3 implements Runnable
{
    @Override
    public void run() {
        for(int i = 1; i <= 10; ++ i)
        {
            System.out.println("hello " + i);
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                throw new RuntimeException(e);
            }
        }
    }
}

用户线程和守护线程

用户线程：也叫工作线程，当线程的任务执行完或以通知的形式结束

守护线程：一般是为用户线程工作的，当所有用户线程结束守护线程自动结束

常见的守护线程：垃圾回收机制

package Method;

public class ThreadMethod03 {
    public static void main(String[] args) throws InterruptedException {
        MyDaemonThread myDaemonThread = new MyDaemonThread();
        //我们希望当主线程结束后子线程能自动结束，我们需要将子线程设置为守护线程
        myDaemonThread.setDaemon(true);
        myDaemonThread.start();
        for (int i = 1; i <= 10; ++i)
        {
            System.out.println("阿杜在辛苦的工作");
            Thread.sleep(1000);
        }
    }
}

class MyDaemonThread extends Thread
{
    @Override
    public void run() {
        for(;;)
        {
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                throw new RuntimeException(e);
            }
            System.out.println("阿杜和阿范一直在聊天~~~~~");
        }
    }
}

线程的七大状态

线程同步

在多线程中，对一些敏感数据可能同一时刻只允许一个线程访问，为了保证数据的完整性，任何同一时刻我们都只让一个线程访问

synchronized

package syn;

class SellTicket03 implements Runnable
{
    private static int num = 100;
    private boolean loop = true;
    public synchronized void sell(){
        if(num <= 0)
        {
            System.out.println("售票结束。。。。");
            loop = false;
            return;
        }
        while(loop)
        {
            if(num <= 0)
            {
                System.out.println("售票结束...");
                break;
            }
            //休眠50ms
            try {
                Thread.sleep(50);
            } catch (InterruptedException e) {
            }
            System.out.println("窗口 " + Thread.currentThread().getName() +
                    "售出一张票" + "剩余票数 = " + (-- num));
        }
    }

    @Override
    public void run() {
       sell();
    }
}
//使用多线程模拟三个窗口同时售票
public class SellTicket {
    public static void main(String[] args) {
        SellTicket03 sellTicket03 = new SellTicket03();
        SellTicket03 sellTicket031 = new SellTicket03();
        Thread thread = new Thread(sellTicket03);
        Thread thread1 = new Thread(sellTicket031);
        thread.start();
        thread1.start();
    }
}

锁

互斥锁

上面的同步机制就是利用了锁，当多个线程运行时，他们先争夺锁，只有获得锁的线程才能执行方法，上面的售卖票利用的就是互斥锁

1、java引入互斥锁的概念是为了保证共享数据的完整性

2、互斥锁，用关键字synchronized修饰时表明该对象在任何同一时刻只能有一个线程访问

3、同步之后因为同一时刻只有一个线程在执行，所以效率自然会降低

4、如果锁加在方法上，如果方法是静态的，锁加在类上，如果方法是非静态的，锁加在当前对象（this）上或则其他对象上（并不是很理解呜呜呜~~~~~）

互斥锁想要起作用，多个线程锁的对象必须是同一个

死锁

双方都需要当前对方所拥有的锁资源

package syn;

public class DeadLock_ {
    public static void main(String[] args) {
        DeadLockDemo deadLockDemo = new DeadLockDemo(false);
        DeadLockDemo deadLockDemo1 = new DeadLockDemo(true);
        deadLockDemo1.start();
        deadLockDemo.start();
    }
}

class DeadLockDemo extends Thread
{
    static Object o1 = new Object();
    static Object o2 = new Object();
    boolean flag;

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

    @Override
    public void run() {
        if(flag)
        {
            synchronized (o1)
            {
                System.out.println(Thread.currentThread().getName() + "进入了o1");
                synchronized (o2)
                {
                    System.out.println(Thread.currentThread().getName() + "进入了o2");
                }
            }
        }else{
            synchronized (o2)
            {
                System.out.println(Thread.currentThread().getName() + "进入了o2");
                synchronized (o1)
                {
                    System.out.println(Thread.currentThread().getName() + "进入了o1");
                }
            }
        }
    }
}

释放锁

释放锁



不会释放锁