线程&&同步

最新推荐文章于 2022-07-11 22:49:34 发布

金融_小陆

最新推荐文章于 2022-07-11 22:49:34 发布

阅读量110

点赞数

分类专栏： javase 笔记代码文章标签： java postgresql

本文链接：https://blog.csdn.net/weixin_43150070/article/details/120315826

版权

javase 同时被 3 个专栏收录

21 篇文章 0 订阅

订阅专栏

笔记

21 篇文章 0 订阅

订阅专栏

代码

13 篇文章 0 订阅

订阅专栏

线程&&同步

多线程原理

在这里插入图片描述

public class MyThread extends Thread{ /** 利用继承中的特点 * 将线程名称传递 进行设置 */
    public MyThread(String name){ 
        super(name); 
    }/** 重写run方法 * 定义线程要执行的代码 */ 
    public void run(){ 
        for (int i = 0; i < 20; i++) {
            //getName()方法 来自父亲 
            System.out.println(getName()+i);
        } 
    }
}

public class Demo {
    public static void main(String[] args){ 
        System.out.println("这里是main线程"); 
        MyThread mt = new MyThread("小强"); 
        mt.start();
        //开启了一个新的线程 
         for (int i = 0; i < 20; i++) { 
             System.out.println("旺财:"+i); 
         }
    } 
}

在这里插入图片描述

创建线程的两种方式

//第一种
public class MyRunnable implements Runnable{ @Override 
    public void run() {
        for (int i = 0; i < 20; i++) { 
           System.out.println(Thread.currentThread().getName()+" "+i);
        }
    } 
}



public class Demo {
    public static void main(String[] args) {
        //创建自定义类对象 线程任务对象 
        MyRunnable mr = new MyRunnable(); 
        //创建线程对象 
        Thread t = new Thread(mr, "小强");         
         t.start();
        for (int i = 0; i < 20; i++) { 
            System.out.println("旺财 " + i);
        } 
    } 
}

//第二种
public class MyRunnable implements Runnable{ 
    @Override 
    public void run() { 
    for (int i = 0; i < 20; i++) {     System.out.println(Thread.currentThread().getName()+" "+i); 
        }
    }
}

public class Demo { 
    public static void main(String[] args) { 
        //创建自定义类对象 线程任务对象 
        MyRunnable mr = new MyRunnable();
        //创建线程对象 
        Thread t = new Thread(mr, "小强"); t.start(); 
        for (int i = 0; i < 20; i++) { System.out.println("旺财 " + i); 
                                                                                 } 
    }
}

通过实现Runnable接口，使得该类有了多线程类的特征。run()方法是多线程程序的一个执行目标。所有的多线程代码都在run方法里面。Thread类实际上也是实现了Runnable接口的类。

在启动的多线程的时候，需要先通过Thread类的构造方法Thread(Runnable target) 构造出对象，然后调用Thread 对象的start()方法来运行多线程代码。

实际上所有的多线程代码都是通过运行Thread的start()方法来运行的。因此，不管是继承Thread类还是实现 Runnable接口来实现多线程，最终还是通过Thread的对象的API来控制线程的，熟悉Thread类的API是进行多线程编程的基础。

总结： Runnable接口比继承Thread类所具有的优势：

适合多个相同的程序代码的线程去共享同一个资源。
可以避免java中的单继承的局限性。
增加程序的健壮性，实现解耦操作，代码可以被多个线程共享，代码和线程独立。
线程池只能放入实现Runable或Callable类线程，不能直接放入继承Thread的类

线程安全

 private static int ticket = 100;
  //  Lock lock = new ReentrantLock();
 //Object lock = new Object();
    @Override
    public void run() {

        while (true) {
          // lock.lock();
         //synchronized关键字可以用于方法中的某个区块中，表示只对这个区块的资源实行互斥访问。  // synchronized (lock){}
            if (ticket >= 0) {
                try {
                    Thread.sleep(50);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                String name = Thread.currentThread().getName();
                System.out.println(name + "正在出票 剩余：" + ticket--);
            }
            lock.unlock();
        }
    }

 public static void main(String[] args) {
        MyRunnable mr = new MyRunnable();
      /*  while(true){
            Thread t  = new Thread(mr,"线程个数： ");
            t.start();
        }*/
        Ticket ticket = new Ticket();
        Thread t1 = new Thread(ticket,"窗口1");
        Thread t2 = new Thread(ticket,"窗口2");
        Thread t3 = new Thread(ticket,"窗口3");
        Thread t4 = new Thread(ticket,"窗口4");
        t1.start();
        t2.start();
        t3.start();

    }

在这里插入图片描述

几个窗口(线程)票数不同步了，这种问题称为线程不安全。

线程安全问题都是由全局变量及静态变量引起的。若每个线程中对全局变量、静态变量只有读操作，而无写 操作，一般来说，这个全局变量是线程安全的；若有多个线程同时执行写操作，一般都需要考虑线程同步， 否则的话就可能影响线程安全。

同步代码块

synchronized(同步锁){ 需要同步操作的代码 }

java.util.concurrent.locks.Lock 机制提供了比synchronized代码块和synchronized方法更广泛的锁定操作, 同步代码块/同步方法具有的功能Lock都有,除此之外更强大,更体现面向对象。 Lock锁也称同步锁，加锁与释放锁方法化了，如下： public void lock() :加同步锁。 public void unlock() :释放同步锁。

线程状态概述

在这里插入图片描述

Timed Waiting在API中的描述为：一个正在限时等待另一个线程执行一个（唤醒）动作的线程处于这一状态。单独的去理解这句话，真是玄之又玄，其实我们在之前的操作中已经接触过这个状态了，在哪里呢？

在我们写卖票的案例中，为了减少线程执行太快，现象不明显等问题，我们在run方法中添加了sleep语句，这样就强制当前正在执行的线程休眠（暂停执行），以“减慢线程”。其实当我们调用了sleep方法之后，当前执行的线程就进入到“休眠状态”，其实就是所谓的Timed Waiting(计时等待)，那么我们通过一个案例加深对该状态的一个理解。

实现一个计数器，计数到100，在每个数字之间暂停1秒，每隔10个数字输出一个字符串

package Thread;

public class TimeWaiting extends Thread {
    @Override
    public void run() {
        super.run();
        for (int i = 0; i < 100; i++) {
            if ((i) % 10 == 0){
                System.out.println("==========="+i);
            }
            System.out.println(i);
        try {
            Thread.sleep(100);
            System.out.println("   线程睡眠1秒");
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        }
    }

    public static void main(String[] args) {
        new TimeWaiting().start();
    }
}

1. 进入 TIMED_WAITING 状态的一种常见情形是调用的 sleep 方法，单独的线程也可以调用，不一定非要有协 作关系。
2. 为了让其他线程有机会执行，可以将Thread.sleep()的调用放线程run()之内。这样才能保证该线程执行过程 中会睡眠 3. sleep与锁无关，线程睡眠到期自动苏醒，并返回到Runnable（可运行）状态。 小提示：sleep()中指定

在这里插入图片描述

Wating(无线等待)状态在API中介绍为：一个正在无限期等待另一个线程执行一个特别的（唤醒）动作的线程处于这一状态。

package Thread;

public class WaitingTest {
    public static Object obj = new Object();

    public static void main(String[] args) {
        new Thread(new Runnable() {
            @Override
            public void run() {
                while (true) {
                    synchronized (obj) {
                        try {
                            System.out.println(Thread.currentThread().getName() + "===获取到锁对象，调用wait方法进入wait状态，释放锁对象");
                            obj.wait();
                        } catch (InterruptedException e) {
                            e.printStackTrace();
                        }
                    }
                }
            }
        }, "等待线程").start();
        new Thread(new Runnable() {
            @Override
            public void run() {

                synchronized (obj) {
                    try {
                        System.out.println(Thread.currentThread().getName() + "===等待3秒");
                        Thread.sleep(3000);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                    synchronized (obj) {
                        System.out.println(Thread.currentThread().getName() + "---------获取到锁对象，调用notify方法，释放锁对象");
                        obj.notify();
                    }
                }

            }
        }, "唤醒线程").start();
    }
}

其实waiting状态并不是一个线程的操作，它体现的是多个线程间的通信，可以理解为多个线程之间的协作关系，多个线程会争取锁，同时相互之间又存在协作关系。就好比在公司里你和你的同事们，你们可能存在晋升时的竞争，但更多时候你们更多是一起合作以完成某些任务。

当多个线程协作时，比如A，B线程，如果A线程在Runnable（可运行）状态中调用了wait()方法那么A线程就进入了Waiting（无限等待）状态，同时失去了同步锁。假如这个时候B线程获取到了同步锁，在运行状态中调用了 notify()方法，那么就会将无限等待的A线程唤醒。注意是唤醒，如果获取到锁对象，那么A线程唤醒后就进入

Runnable（可运行）状态；如果没有获取锁对象，那么就进入到Blocked（锁阻塞状态）。

在这里插入图片描述