Java线程的创建和运行

小鱼儿 2024-04-08 11:32 8阅读 0赞

#### 文章目录 ####

*  1.线程的创建方式
 *   *  1.1 继承Thread类，重写run方法
     *  1.2 使用 Runnable 配合 Thread
     *  1.3 FutureTask 配合 Thread
 *  2 通知线程退出
 *  3.实现原理
 *  3.线程常用方法
 *   *  3.1 setName：设置线程名称，使之与参数name相同
     *  3.2 getName：返回该线程的名称
     *  3.3 start：使该线程开始执行；Java虚拟机底层调用该线程的start0 方法
     *  3.4 run：调用线程对象的run方法
     *  3.5 setPriority：更改线程的优先级
     *  3.6 getPriority： 获取线程的优先级
     *  3.7 sleep：在指定的毫秒数内让当前正在执行的线程休眠(暂停执行)
     *  3.8 interrupt
     *  3.9 yield
     *  3.10 join
     *  3.11 getState:获取线程的状态
 *  4.用户线程和守护线程
 *  5.线程的生命周期
 *  6.线程安全
 *  7.线程同步机制
 *   *  7.1 同步具体方法-Synchronized
     *  7.2 Lock锁
     *  7.3 Lock与synchronized对比
 *  8.互斥锁(就是上面的对象锁)
 *  9.线程死锁
 *  10.释放锁

## 1.线程的创建方式 ##

![在这里插入图片描述][267e2505a94143c3bf883908a86ef117.png]

### 1.1 继承Thread类，重写run方法 ###

// 创建线程对象,构造方法的参数是给线程指定名字，推荐
    Thread t1 = new Thread("t1") {
        
    	@Override
    	// run 方法内实现了要执行的任务
    	public void run() {
        
    		log.debug("hello");
    } };
    t1.start();

### 1.2 使用 Runnable 配合 Thread ###

（1）把【线程】和【任务】（要执行的代码）分开  
①Thread 代表线程  
②Runnable 可运行的任务（线程要执行的代码）

// 创建任务对象
    Runnable task2 = new Runnable() {
        
    	@Override
    	public void run() {
        
    		log.debug("hello");
    } };
    // 参数1 是任务对象; 参数2 是线程名字，推荐
    Thread t2 = new Thread(task2, "t2");
    t2.start();

（2）Thread 与 Runnable 的关系  
①继承Thread类是把线程和任务合并在了一起，使用 Runnable 配合 Thread是把线程和任务分开了  
②用 Runnable 更容易与线程池等高级 API 配合  
③用 Runnable 让任务类脱离了 Thread 继承体系，更灵活  
④Java是单继承的，在某些情况下一个类可能已经继承了某个父类，这时再用继承Thread类方法来实现创建线程显然不可能了。  
⑤Java设计者提供了另外一种创建线程的方法，就是通过实现Runnable接口来创建线程。实现Runnable接口方式更加适合多个线程共享一个资源的情况，并且避免了单继承的限制，建议使用Runnable

（3）Java 8 以后可以使用 lambda 精简代码

// 创建任务对象
    Runnable task2 = () -> log.debug("hello");
    // 参数1 是任务对象; 参数2 是线程名字，推荐
    Thread t2 = new Thread(task2, "t2");
    t2.start();

### 1.3 FutureTask 配合 Thread ###

（1）FutureTask 能够接收 Callable 类型的参数，用来处理有返回结果的情况  
![在这里插入图片描述][3da6bad31c124721895536356f8bfa2b.png]  
（2）Callable与Runnable区别是有返回值，可以抛异常  
（3）例子：

public class DemoFutureTask {
        
    
        public static void main(String[] args) throws ExecutionException, InterruptedException {
        
           FutureTask<Integer> task = new FutureTask<>(new Callable<Integer>() {
        
               @Override
               public Integer call() throws Exception {
        
                   return 100;
               }
           });
            Thread t1 = new Thread(task,"t1");
            t1.start();
            System.out.println(task.get()); //100
    
        }
    }

## 2 通知线程退出 ##

（1）当线程退出后,会自动退出  
（2）还可以通过使用变量来控制run方法退出的方式停止线程，即通知方式

public class Thread_exit {
        
        public static void main(String[] args) throws InterruptedException {
        
            T t = new T();
            t.start();
    //        如果希望main线程去控制t1 线程的终止，可以修改 loop
    //        让t1 退出run方法，从而终止 t1线程 -> 通知方式
    //        让主线程休眠 10秒，再通知 t1线程退出
            Thread.sleep(10 * 1000);
            t.setLoop(false);
        } }
    class T extends Thread {
        
        private int count = 0;
        //    设置一个控制变量
        private boolean loop = true;
        public void setLoop(boolean loop) {
        
            this.loop = loop;
        }
        @Override
        public void run() {
        
            while (loop) {
        
                System.out.println("我是" + (++count) + "线程名=" + Thread.currentThread().getName());
    //        让线程休眠1秒
                try {
        
                    Thread.sleep(1000);
                } catch (InterruptedException e) {
        
                    e.printStackTrace();
                }
                if (count == 10) {
        
                    break;
                } } } }

## 3.实现原理 ##

（1） start()方法源码：  
① public synchronized void start() \{  
start0();  
\}  
② start0() 是本地方法，是JVM调用，底层是c/c++实现  
真正实现多线程效果的是start0()，而不是 run  
private native void start0();  
\*/  
（2）  
![在这里插入图片描述][a42ae2471d96403ea6997fb6fc91274f.png]

## 3.线程常用方法 ##

### 3.1 setName：设置线程名称，使之与参数name相同 ###

### 3.2 getName：返回该线程的名称 ###

### 3.3 start：使该线程开始执行；Java虚拟机底层调用该线程的start0 方法 ###

### 3.4 run：调用线程对象的run方法 ###

### 3.5 setPriority：更改线程的优先级 ###

（1）线程优先级会提示（hint）调度器优先调度该线程，但它仅仅是一个提示，调度器可以忽略它  
（2）如果 cpu 比较忙，那么优先级高的线程会获得更多的时间片，但 cpu 闲时，优先级几乎没作用  
![在这里插入图片描述][f48511248ebb44c2939d943805c3d9ce.png]

### 3.6 getPriority： 获取线程的优先级 ###

### 3.7 sleep：在指定的毫秒数内让当前正在执行的线程休眠(暂停执行) ###

(1)调用 sleep 会让当前线程从 Running 进入 Timed Waiting 状态（阻塞）  
(2)其它线程可以使用 interrupt 方法打断正在睡眠的线程，这时 sleep 方法会抛出 InterruptedException  
![在这里插入图片描述][0cc2724de930424a95c671fc567d9c9d.png]

(3) 睡眠结束后的线程未必会立刻得到执行(睡眠结束以后CPU可能正在执行其他的线程)  
(4) 建议用 TimeUnit 的 sleep 代替 Thread 的 sleep 来获得更好的可读性(有时间的单位)  
例如：TimeUnit.SECONDS.sleep(1000);

### 3.8 interrupt ###

（1）打断sleep，wait，join这些处于阻塞的线程，并且会清空打断状态

private static void test1() throws InterruptedException {
        
    Thread t1 = new Thread(()->{
        
    	sleep(1);
    	}, "t1");
    	t1.start();
    	sleep(0.5);
    	t1.interrupt();
    	log.debug(" 打断状态: {}", t1.isInterrupted());//false
    }

（2）打断正常运行的线程  
被打断的线程只是知道有其他线程想要打断自己,但是被打断的线程是由自己决定继续运行还是停止运行。  
打断正常运行的线程, 不会清空打断状态。我们可以根据打断状态来判断是继续运行还是停止运行。

public class DemoInterrupt {
        
        public static void main(String[] args) throws InterruptedException {
        
    //只是知道有其他线程想要打断我,但是被打断的线程是由自己决定继续运行还是停止运行
            Thread t1 = new Thread(() -> {
        
                while (true) {
        
                    boolean interrupted = Thread.currentThread().isInterrupted();
                    if (interrupted) {
        
                        System.out.println("有人要打断你");
                        break;
                    } } });
            t1.start();
            Thread.sleep(1000);
            t1.interrupt();
        } }

### 3.9 yield ###

(1)线程的礼让。让出CPU，让其他线程执行，但礼让的时间不确定，所以也不一定礼让成功。具体的实现  
依赖于操作系统的任务调度器  
(2)调用 yield 会让当前线程从 Running 进入 Runnable 就绪状态，然后调度执行其它线程

### 3.10 join ###

线程的插队。插队的线程一旦插队成功，则肯定先执行完插入的线程所有的任务

### 3.11 getState:获取线程的状态 ###

## 4.用户线程和守护线程 ##

（1）用户线程：也叫工作线程，当线程的任务执行完或通知方式结束  
（2）守护线程：一般是为工作线程服务的，当所有用户线程结束，守护线程自动结束  
常见的守护线程：垃圾回收机制  
（3）把线程设置为守护线程例子

public class ThreadMethod3 {
        
        public static void main(String[] args) throws InterruptedException {
        
            T3 t3 = new T3();
    //        如果我们希望当main线程结束后，子线程自动结束
    //        只需将子线程设为守护线程即可
            t3.setDaemon(true);
            t3.start();
            for (int i = 0; i < 10; i++) {
        //主线程
                System.out.println("别卷了..."+i);
                Thread.sleep(1000);
            } } }
    class T3 extends Thread{
        
        @Override
        public void run() {
        
            while (true){
        
                try {
        
                    Thread.sleep(1000);//休息1秒
                } catch (InterruptedException e) {
        
                    e.printStackTrace();
                }
                System.out.println("在学Java...");
            } } }

## 5.线程的生命周期 ##

Java中用Thread.State枚举表示了线程的几种状态。  
public static enum Thread.State extends Enum<Thread.State>线程状态。线程可以处于下列状态之一：  
（1）NEW  
至今尚未启动的线程。  
（2）RUNNABLE  
正在 Java 虚拟机中执行的线程  
（3）BLOCKED  
受阻塞并等待获得同步代码块的锁的线程  
（4）WAITING  
无限期地等待另一个线程来执行某一特定操作  
（5）TIMED\_WAITING  
等待另一个线程来执行操作，取决于指定的等待时间  
（6）TERMINATED  
已退出的线程。  
注意：RUNNABLE 是否真的运行取决于调度器，由操作系统内核来决定，可以细分为Ready就绪和Running运行

## 6.线程安全 ##

如果有多个线程在同时运行，而这些线程可能会同时运行这段代码。程序每次运行结果和单线程运行的结果是一样的，而且其他的变量的值也和预期的是一样的，就是线程安全的。  
我们通过一个案例，演示线程的安全问题：  
电影院要卖票，我们模拟电影院的卖票过程。假设要播放的电影是 “葫芦娃大战奥特曼”，本次电影的座位共100个(本场电影只能卖100张票)。  
我们来模拟电影院的售票窗口，实现多个窗口同时卖 “葫芦娃大战奥特曼”这场电影票(多个窗口一起卖这100张票)  
需要窗口，采用线程对象来模拟；需要票，Runnable接口子类来模拟  
模拟票：

public class Ticket implements Runnable {
        
    private int ticket = 100;
    /*
    * 执行卖票操作
    */
    @Override
    public void run() {
        
    //每个窗口卖票的操作
    //窗口 永远开启
    while (true) {
        
    if (ticket > 0) {
        //有票 可以卖
    //出票操作
    //使用sleep模拟一下出票时间
    try {
        
    Thread.sleep(100);
    } catch (InterruptedException e) {
        
    // TODO Auto‐generated catch block
    e.printStackTrace();
    } /
    /获取当前线程对象的名字
    String name = Thread.currentThread().getName();
    System.out.println(name + "正在卖:" + ticket‐‐);
    }}}}
    //测试类：
    public class Demo {
        
    public static void main(String[] args) {
        
    //创建线程任务对象
    Ticket ticket = new Ticket();
    //创建三个窗口对象
    Thread t1 = new Thread(ticket, "窗口1");
    Thread t2 = new Thread(ticket, "窗口2");
    Thread t3 = new Thread(ticket, "窗口3");
    //同时卖票
    t1.start();
    t2.start();
    t3.start();
    } }

![在这里插入图片描述][b98f95a741c6405eb33a1a055ae5e329.png]

## 7.线程同步机制 ##

（1）在多线程编程，一些敏感数据不允许被多个线程同时访问，此时就使用同步访问技术，保证数据在任何时刻，最多有一个线程访问，以保证数据的完整性。  
（2）也可以这样理解：线程同步，即当有一个线程在对内存进行操作时，其他线程都不可以对这个内存地址进行操作，直到该线程完成操作，其他线程才能对该内存地址进行操作。

### 7.1 同步具体方法-Synchronized ###

（1）同步代码块  
synchronized(对象) \{ //得到对象的锁，才能操作同步代码  
// 需要被同步的代码；  
\}  
（2）synchronized还可以放在方法声明中，表示整个方法为同步方法  
public synchronized void m(String name) \{  
// 需要被同步的代码  
\}

### 7.2 Lock锁 ###

（1）从JDK5.0 开始，Java提供了更强大的线程同步机制——通过显示定义同步锁对象来实现同步；同步锁使用Lock对象充当  
（2）java.util.concurrent.locks.Lock接口是控制多个线程对资源进行访问的工具。锁提供了对共享资源的独占访问，每次只能有一个线程对Lock对象加锁，线程开始访问共享资源之前应先获得Lock对象  
（3）ReentrantLock类实现了Lock，它拥有与synchronized相同的并发性和内存语义，在实现线程安全的控制中，比较常用的是ReentrantLock，可以显示加锁、释放锁

// 获取锁
    reentrantLock.lock();
    try {
        
    	// 临界区
    } finally {
        
    	// 释放锁
    	reentrantLock.unlock();
    }

public class TestLock {
        
        public static void main(String[] args) {
        
            DemoLock demoLock = new DemoLock();
            new Thread(demoLock).start();
            new Thread(demoLock).start();
            new Thread(demoLock).start();
     } }
    class DemoLock implements Runnable {
        
        int tickNums = 10;
        //定义lock锁
        private final ReentrantLock lock = new ReentrantLock();
        @Override
        public void run() {
        
            while (true) {
        
                lock.lock();//加锁(位置放在try块里面和外面效果都一样)
                try {
        
                    if (tickNums > 0) {
        
                        System.out.println(tickNums--);
                    } else {
        
                        break;
                    }
                } finally {
        
                    lock.unlock();//解锁
                }  } } }

### 7.3 Lock与synchronized对比 ###

（1）Lock是显示锁(手动开启和关闭锁)，synchronized是隐式锁，出了作用域自动释放  
（2）Lock只有代码块锁，synchronized有代码块锁和方法锁  
（3）使用Lock锁，JVM将花费较短时间来调度线程，性能更好。并且具有更好的扩展性(提供了更多的子类)  
（4）ReentrantLock可中断,可以设置超时时间,可以设置为公平锁,支持多个条件变量;与 synchronized 一样，  
都支持可重入  
①可重入是指同一个线程如果首次获得了这把锁，那么因为它是这把锁的拥有者，因此有权利再次获取这把锁;  
如果是不可重入锁，那么第二次获得锁时，自己也会被锁挡住

static ReentrantLock lock = new ReentrantLock();
    public static void main(String[] args) {
        
    	method1();
    }
    public static void method1() {
        
    	lock.lock();
    	try {
        
    		log.debug("execute method1");
    		method2();
    } finally {
        
    	lock.unlock();
       } }
    //第二次调用和第三次调用就相当于重入
    public static void method2() {
        
    	lock.lock();
    	try {
        
    		log.debug("execute method2");
    		method3();
    	} finally {
        
    		lock.unlock();
    } }

②可打断，等待锁的过程中，其他线程可以使用interrupt方法终止我的等待  
(获取锁方式为lock.lockInterruptibly())

public class Test1 {
        
        private static ReentrantLock lock = new ReentrantLock();
        public static void main(String[] args) {
        
            Thread t1 = new Thread(() -> {
        
                try {
        
    //  如果没有竞争那么此方法就会获取lock对象锁
    //  如果有竞争就会进入阻塞队列，可以被其他线程使用 interrupt方法打断
                    System.out.println("尝试获取锁");
                    lock.lockInterruptibly();
                } catch (InterruptedException e) {
        
                    e.printStackTrace();
                    System.out.println("没有获得锁,返回");
                    return;
                }
                try {
        
                    System.out.println("获取到锁");
                } finally {
        
                    lock.unlock();
                }});
            lock.lock();//主线程获取锁
            t1.start();//t1线程
            t1.interrupt();//打断t1
        } }

③锁超时(获取锁的方式为lock.tryLock())  
还可以设置超时时间-lock.tryLock(1, TimeUnit.SECONDS)

ReentrantLock lock = new ReentrantLock();
    Thread t1 = new Thread(() -> {
        
    	log.debug("启动...");
    	if (!lock.tryLock()) {
        
    		log.debug("获取锁失败，返回");
    		return;
    }
    	try {
        
    		log.debug("获得了锁");
    	} finally {
        
    		lock.unlock();
    } }, "t1");
    	lock.lock();//主线程获取锁
    	log.debug("获得了锁");
    	t1.start();
    	try {
        
    		sleep(2);
    	} finally {
        
    		lock.unlock();
    	}

④ReentrantLock 默认是不公平的(公平锁一般没有必要，会降低并发度)  
ReentrantLock lock = new ReentrantLock(false);//改为公平锁  
不公平锁：当一个线程池有锁，其他线程就会进入阻塞队列去等待，当锁的持有者释放锁时，这些线程就会一涌而上，谁先抢到谁就先获得锁，而不会按照进入阻塞队列的顺序  
l

## 8.互斥锁(就是上面的对象锁) ##

（1）在Java语言中，引入了对象互斥锁的概念，来保证共享数据操作的完整性  
（2）每个对象都对应于一个可称为“互斥锁”的标记，这个标记用来保证在任一时刻，只能有一个线程访问  
（3）关键字synchronized 用来与对象的互斥锁联系。当某个对象用synchronized修饰时，表明该对象在任一时刻只能由一个线程访问。  
（4）同步的局限性：导致程序的执行效率要降低  
（5）同步方法(非静态的)的锁可以是this，也可以是其他对象(要求是同一个对象)  
（6）同步方法(静态的)的锁为当前类本身  
注意事项：  
①同步方法如果没有使用static修饰，默认锁对象为this  
②如果方法使用static修饰，默认锁对象：当前类.class  
例子：

//1.同步方法没有使用static修饰
    public class SellTicket02 {
        
        public static void main(String[] args) {
        
            T2 t2 = new T2();
            new Thread(t2).start();//第一个线程窗口
            new Thread(t2).start();//第二个线程窗口
            new Thread(t2).start();//第三个线程窗口
        } }
    class T2 implements Runnable {
        
        private int ticketNum = 100;//让多个线程共享 ticketNum
        private boolean loop = true;
        Object object = new Object();
        public void sell() {
        
            synchronized (/*this*/object) {
        
                if (ticketNum <= 0) {
        
                    System.out.println("售票结束。。。");
                    loop = false;
                    return;
                }
    //            休眠50秒
                try {
        
                    Thread.sleep(50);
                } catch (InterruptedException e) {
        
                    e.printStackTrace();
                }
                System.out.println("窗口" + Thread.currentThread().getName() + "售出一张票"
                        + "剩余票数=" + (--ticketNum));
            } }
        @Override
        public void run() {
        
            while (loop) {
        
                sell();
            } } }

// 2.同步方法为静态方法
    public class SellTicket05 {
        
        public static void main(String[] args) {
        
            T2 t2 = new T2();
            new Thread(t2).start();//第一个线程窗口
            new Thread(t2).start();//第二个线程窗口
            new Thread(t2).start();//第三个线程窗口
        } }
    class T5 implements Runnable {
        
        private static int ticketNum = 100;//让多个线程共享 ticketNum
        private static boolean loop = true;
        public static void sell() {
        
            synchronized (T5.class) {
        
                if ( ticketNum<= 0) {
        
                    System.out.println("售票结束。。。");
                    loop = false;
                    return;
                }
    //            休眠50秒
                try {
        
                    Thread.sleep(50);
                } catch (InterruptedException e) {
        
                    e.printStackTrace();
                }
                System.out.println("窗口" + Thread.currentThread().getName() + "售出一张票"
                        + "剩余票数=" + (--ticketNum));
            } }
        @Override
        public void run() {
        
            while (loop) {
        
                sell();
            } } }

## 9.线程死锁 ##

多个线程都占用了对方的锁资源，但不肯想让，导致了死锁，在编程时一定要避免死锁的发生

public class DeadLock {
        
        public static void main(String[] args) {
        
            DemoDeadLock A = new DemoDeadLock(true);
            DemoDeadLock B = new DemoDeadLock(false);
            A.start();
            B.start();
        } }
    class DemoDeadLock extends Thread {
        
        static Object o1 = new Object();
        static Object o2 = new Object();
        boolean flag;
        public DemoDeadLock(boolean flag) {
        
            this.flag = flag;
        }
        @Override
        public void run() {
        
    //业务逻辑分析:
    // 1.如果flag 为T,线程A 就会先得到 o1 对象锁，然后尝试去获取 o2 对象锁
    // 2.如果线程A 得不到 o2 对象锁，就会Blocked
    // 3.如果flag 为F,线程B 就会先得到 o2 对象锁，然后尝试去获取 o1 对象锁
    // 4.如果线程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() + "进入2");
                    synchronized (o1) {
        
                        System.out.println(Thread.currentThread().getName() + "进入1");
                    } } } } }

## 10.释放锁 ##

（1）当前线程的同步方法、同步代码块执行结束  
（2）当前线程在同步代码块、同步方法中遇到break、return  
（3）当前线程在同步代码块、同步方法中出现了未处理的Error或Exception，导致异常结束  
（4）当前线程在同步代码块、同步方法中执行了线程对象的wait()方法，当前线程暂停，并释放锁  
下面操作不会释放锁：  
①线程执行同步代码块或同步方法时，程序调用Thread.sleep()、Thread.yield()方法暂停当前线程的执行，不会释放锁  
②线程执行同步代码块时，其他线程调用了该线程的suspend()方法将该线程挂起，该线程不会释放锁  
提示：应尽量避免使用suspend()和resume()来控制线程，该方法不再推荐使用

[267e2505a94143c3bf883908a86ef117.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/08/ae638dbe024f44778dbdf5825f84b4f4.png
[3da6bad31c124721895536356f8bfa2b.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/08/86cb53ab6edc4963bc949669537b7255.png
[a42ae2471d96403ea6997fb6fc91274f.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/08/4d231bb40dbe4f338ed62d3b2dfb37c4.png
[f48511248ebb44c2939d943805c3d9ce.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/08/b5eeec427a7f4501b25ead45dfa166cc.png
[0cc2724de930424a95c671fc567d9c9d.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/08/f94769b6f03e4bc8895ee66257e54b77.png
[b98f95a741c6405eb33a1a055ae5e329.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/08/2f79a10463a44eb4843c26ff437eab7b.png