Java线程

小俱的一步步

已于 2023-02-03 22:16:56 修改

阅读量149

点赞数 4

分类专栏： JavaSE 文章标签： java jvm 开发语言

于 2023-02-03 12:57:08 首次发布

本文链接：https://blog.csdn.net/weixin_63541561/article/details/128862403

版权

JavaSE 专栏收录该内容

13 篇文章 0 订阅

订阅专栏

Lock锁和synchornized锁的区别：

程序进程线程

程序(program): 静态的代码，没有运行的，在电脑上安装的静态的代码文件。

进程(process): 运行中的程序--进程, 是操作系统进行资源分配的最小单位。

线程(thread): 线程是进程中最小的执行单元, cpu都是以线程为单位来调度的，是cpu执行的最小单位，一个线程,就是一个独立的任务

线程和进程的关系：

1.一个进程可以包含多个线程，一个线程只能属于一个进程，线程不能脱离进程而独立运行；
2. 每一个进程至少包含一个线程(称为主线程)；在主线程中开始执行程序， java程序的入口main()方法就是在主线程中被执行的。
3. 在主线程中可以创建并启动其它的线程；
4.一个进程内的所有线程共享该进程的内存资源。

创建线程

一. 继承Thread类的方式

扩展Thread类，重写其中的run方法

定义：
public class MyThread extends Thread {

@Override

public void run() {
}
}

调用：
MyThread thread = new MyThread();
thread.start();

Thread类中方法

二.实现Runnable接口的方式

java.lang.Runnable接口中仅仅只有一个抽象方法：
通过实现Runnable接口的方式来实现线程，只需要实现其中的run方法即可；
Runnable接口的存在主要是为了解决Java中不允许多继承的问题。

定义：
public class MyThread implements Runnable{
        @Override
        public void run() {
                ……
        }
}

线程执行任务
MyThread r = new MyThread();
创建一个线程作为外壳，将r包起来，
Thread thread = new Thread(r);
thread.start();

实现Runnable接口的好处:

1.可以继承其他的类
2.在多线程处理同一个资源时使用

线程优先级

计算机只有一个CPU，各个线程轮流获得CPU的使用权，才能执行任务；
优先级较高的线程有更多获得CPU的机会，反之亦然；
优先级用整数表示，取值范围是1~10，一般情况下，线程的默认优先级都是5，但是也可以通过setPriority和getPriority方法来设置或返回优先级；

对象名.setPriority(1~10);//设置优先级
Thread.currentThread().getPriority()//获取优先级

Thread类有如下3个静态常量来表示优先级：
1.MAX_PRIORITY：取值为10，表示最高优先级。
2.MIN_PRIORITY：取值为1，表示最底优先级。
3. NORM_PRIORITY：取值为5，表示默认的优先级。

调度策略：

1.时间片
2. 抢占式：高优先级的线程抢占CPU

Java的调度方法：

1.同优先级线程组成先进先出队列，使用时间片策略
2.对高优先级，使用优先调度的抢占式策略

线程状态

线程的状态：
● 新建：当一个Thread类或其子类的对象被声明并创建时，新生的线程对象处于新建状态
● 就绪：处于新建状态的线程被start（）后，将进入线程队列等待CPU时间片，此时它已具备了运行的条件，只是没分配到CPU资源
● 运行：当就绪的线程被调度并获得CPU资源时，便进入运行状态，run（）方法定义了线程的操作和功能
● 阻塞：在某种特殊情况下，被人为挂起或执行输入输出操作时，让出CPU并临时中止自己的执行，进入阻塞状态
● 死亡：线程完成了它的全部工作或线程被提前强制性地中止或出现异常导致结束

龟兔赛跑之乌龟赢

两者谁先跑完1000m谁获胜

MyThread

public class MyThread implements Runnable{
    boolean win = true;

    @Override
    public void run() {
        for (int i = 0; i <=1000; i++) {
            if (Thread.currentThread().getName().equals("兔子")){
                try {
                    if (i==500){//当兔子跑500m时休息10s
                        Thread.sleep(10000);
                    }
                    System.out.println("兔子跑了"+i+"步");
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
            if (Thread.currentThread().getName().equals("乌龟")){
                try {
                    Thread.sleep(1);//乌龟每跑1m休息1ms
                    System.out.println("乌龟跑了"+i+"步");
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
            if (win){//不能排除乌龟与兔子同时赢的情况，但加sleep之后能减少发生的概率，之后可以加锁进行控制
                if (i==1000){
                    System.out.println(Thread.currentThread().getName()+"胜利了");
                    win = false;
                }
            }

        }
    }
}

Test

public class Test {
    public static void main(String[] args) {
        MyThread myThread = new MyThread();
        Thread tz=new Thread(myThread,"兔子");
        Thread wg=new Thread(myThread,"乌龟");
        tz.start();
        wg.start();
    }
}

最后乌龟获胜，兔子跑完1000米

守护线程

Java中的线程分为两类：用户线程和守护线程

任何一个守护线程都是整个JVM中所有非守护线程的保姆,只要当前JVM实例中尚存在任何一个非守护线程没有结束，守护线程就全部工作；

只有当最后一个非守护线程结束时，守护线程随着JVM一同结束工作。
守护线程的作用是为其他线程的运行提供便利服务，守护线程最典型的应用就是 GC(垃圾回收器)，它就是一个很称职的守护者。

用户线程和守护线程两者几乎没有区别，唯一的不同之处就在于虚拟机的离开：如果用户线程已经全部退出运行了，只剩下守护线程存在了，虚拟机也就退出了。因为没有了被守护者，守护线程也就没有工作可做了，也就没有继续运行程序的必要了.

设置守护线程: setDaemon(boolean on)
注意:设置线程为守护线程必须在启动线程之前，否则会跑出一个IllegalThreadStateException异常。

用户线程

//用户线程
public class Mythread extends Thread{
    @Override
    public void run() {
        for (int i = 0; i < 1000; i++) {
            System.out.println("MyThread "+i);
        }
    }
}

守护线程

public class SHThread extends Thread{
    //守护线程
    @Override
    public void run() {

        while (true){
            System.out.println("守护线程");
        }
    }
}

Test类

public class Test {
    public static void main(String[] args) {

        SHThread shThread = new SHThread();
        shThread.setDaemon(true);//放在自己start之前和要守护的线程的之前
        shThread.start();

        Mythread mythread = new Mythread();
        mythread.start();
    }
}

当用户线程结束后，守护线程随之结束

多线程

概念：

多线程是指程序中包含多个执行单元，即在一个程序中可以同时运行多个不同的线程来执行不同的任务，也就是说允许单个程序创建多个并行执行的线程来完成各自的任务。

使用多线程情况：

1.程序要实现两个或多个任务

2.程序需要实现等待的任务，比如等待输入文件读写操作、网络操作、搜索等。

优点：

1.提高CPU的利用率.

2.提高程序的响应.

3.改善程序结构,将复杂任务分为多个线程,独立运行.

缺点

1.线程也是程序，所以线程需要占用内存，线程越多占用内存也越多；

2.多线程需要协调和管理，所以需要CPU时间跟踪线程；

3.线程之间对共享资源的访问会相互影响。

线程同步

并发与并行

● 并行：多个CPU同时执行多个任务。比如：多个人同时做不同的事。
● 并发：在一个时间段内一次执行操作.例如卖票,抢购,秒杀看似同时进行,实际是一个一个执行.

多线程同步

概念：多个线程同时读写同一份共享资源时，可能会引起冲突。所以引入线程“同步”机制，即各线程间要有先来后到；

同步就是排队+锁：
几个线程之间要排队，一个个对共享资源进行操作，而不是同时进行操作；
为了保证数据在方法中被访问时的正确性，在访问时加入锁机制

同步锁

同步锁可以是任何对象,必须唯一,保证多个线程获得是同一个对象(用来充当锁标记).
同步执行过程：
1.第一个线程访问，锁定同步对象，执行其中代码.
2.第二个线程访问，发现同步对象被锁定，无法访问.
3.第一个线程访问完毕，解锁同步对象.
4.第二个线程访问，发现同步对象没有锁，然后锁定并访问.

在Java代码中实现同步：
使用synchronized(同步锁)关键字同步方法或代码块。要添加“（）”,“（）”内中要添加一个对象即锁对象，使用该对象的对象头中的一块空间来记录锁的状态.记录有没有线程进入到同步代码块中。

synchronized修饰代码块：

在继承Thread的类中，锁对象应提前创建，保证多个线程使用的是同一个对象
在实现Rannable的类中，“（）”内可以用this，表示同一个对象

synchronized (同步锁）{
// 需要被同步的代码；
}

synchronized修饰方法：

在继承Thread的类中，synchronized修饰的方法应该添加static关键字
在实现Rannable的类中，可以不添加，此时使用的是该类的Class类的对象

public synchronized void show (String name){
// 需要被同步的代码；
}

例如卖票问题：

两个线程共卖10张票

public class Ticket extends Thread{
    static int num = 10;//线程共用一个
//    static String s=new String();
    @Override
    public void run() {
        while (true){
//            synchronized(s){//必须确保多线程对应的是同一个对象
                if (num>0) {
                    print();
                }
                else break;
            }

        }

//    }
    public static synchronized void print(){
        if (num>0) {
            try {
                Ticket.sleep(10);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println(Thread.currentThread().getName() + "买" + num--);
        }

    }
}

public class Test {
    public static void main(String[] args) {
        Ticket ticket1 = new Ticket();
        ticket1.setName("窗口1");
        ticket1.start();

        Ticket ticket2 = new Ticket();
        ticket2.setName("窗口2");
        ticket2.start();
    }
}

同步执行过程：

1.第一个线程访问，锁定同步对象，执行其中代码.
2.第二个线程访问，发现同步对象被锁定，无法访问.
3.第一个线程访问完毕，解锁同步对象.
4.第二个线程访问，发现同步对象没有锁，然后锁定并访问.

Lock锁

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

Lock锁和synchornized锁的区别：

1.Lock锁是代码控制，synchornized是底层控制

2.Lock锁是显示释放锁，synchornized是隐式释放锁

3.Lock修饰代码块，synchornized修饰方法和代码块

卖票问题应用Lock锁：

import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;


public class Tictek implements Runnable{

    int num=10;//共用一个类，不用加static
    Lock lock = new ReentrantLock();

    @Override
    public void run() {

        while (true){
                if (num>0){
                    printjg();
                }else break;
        }
    }
    public void printjg(){
        lock.lock();//上锁
        try{
            if (num>0){
                try {
                    Thread.sleep(100);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                System.out.println(Thread.currentThread().getName()+"买"+num--);
            }
        }finally {
            lock.unlock();//释放锁
        }
    }
}

public class Test {
    public static void main(String[] args) {
        Tictek tictek = new Tictek();
        Thread t1 = new Thread(tictek,"窗口1");
        Thread t2 = new Thread(tictek,"窗口2");

        t1.start();
        t2.start();
    }
}

线程死锁

不同的线程分别占用对方需要的同步资源不放弃，都在等待对方放弃自己需要的同步资源，就形成了线程的死锁.出现死锁后，不会出现异常，不会出现提示，只是所有的线程都处于阻塞状态，无法继续.

例如：

public class MyThread extends Thread{

    /*
    死锁：
        不同的线程分别占用是对方的同步资源，都等待对方放弃自己的同步资源，出现死锁
     */
    static Object objectA = new Object();
    static Object objectB = new Object();

    Boolean flag;
    public MyThread(boolean flag){
        this.flag=flag;
    }
    @Override
    public void run() {
     if (flag){
         synchronized (objectA){
             System.out.println("if objectA");
             synchronized (objectB){
                 System.out.println("if objectB");
             }
         }
     }else {
         synchronized (objectB){
             System.out.println("else objectB");
             synchronized (objectA){
                 System.out.println("else objectA");
             }
         }
     }
    }
}

public class Test {
    public static void main(String[] args) {
        MyThread myThread1 = new MyThread(true);
        MyThread myThread2 = new MyThread(false);

        myThread1.start();
        myThread2.start();
    }
}

图例：

死锁的可能性非常大，但不排除不出现死锁情况

线程通信

概念：

多个线程通过相互牵制，相互调度，即线程间的相互作用

涉及三个方法：

1.wait一旦执行此方法，当前线程就进入阻塞状态，并释放同步监视器。
2.notify一旦执行此方法，就会唤醒被wait的一个线程。如果有多个线程被wait，就唤醒优先级高的一个。
3.notifyAll一旦执行此方法，就会唤醒所有被wait的线程。

注意：wait（），notify（），notifyAll（）三个方法必须使用在同步代码块或同步方法中。

例题1：两个线程交替打印1~100：

public class MyThread implements Runnable {

    int num = 0;
    @Override
    public void run() {
        synchronized (this) {
            while (true){
                this.notify();
                if(num <= 100) {
                    System.out.println(Thread.currentThread().getName() + ":" + num++);
                    try {
                        this.wait();
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }else {
                    break;
                }
            }

        }
    }
}

public class Test {
    public static void main(String[] args) {
        MyThread thread = new MyThread();
        Thread t1 = new Thread(thread,"线程1");
        Thread t2 = new Thread(thread,"线程2");
        t1.start();
        t2.start();
    }
}

部分结果：

经典例题：生产者/消费者问题

生产者(Productor)将产品放在柜台(Counter)，而消费者(Customer)从柜台
处取走产品，生产者一次只能生产固定数量的产品(比如:3），这时柜台中不能
再放产品,此时生产者应停止生产等待消费者拿走产品,此时生产者唤醒消费者来
取走产品,消费者拿走产品后,唤醒生产者,消费者开始等待

柜台

//柜台
public class Counter {

     int num = 3;
    public synchronized void add(){
                if (num>0){
                    try {
                        this.wait();
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }else {
                    for (int i = 0; i < 3; i++) {
                        num+=1;
                        System.out.println("生产者生产 剩余：" +num);
                        this.notify();//释放消费者
                    }

                }
    }
    public synchronized void sub(){
                if (num==0){
                    try {
                        this.wait();//消费者等待
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }else {
                    for (int i = 0; i < 3; i++) {
                        num-=1;
                        System.out.println("消费者消费 库存："+num);
                        this.notify();
                    }

                }
    }
}

消费者

//消费者
public class Customer extends Thread{
    Counter counter;

    public Customer(Counter counter) {
        this.counter = counter;
    }

    @Override
    public void run() {
        while (true){
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            counter.sub();
        }

    }

}

生产者

//生产者
public class Protect extends Thread{
    Counter counter;

    public Protect(Counter counter) {
        this.counter = counter;
    }

    @Override
    public void run() {
        while (true){
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            counter.add();
        }

    }

}

Test

public class Test {
    public static void main(String[] args) {
        Counter counter = new Counter();
        Customer customer = new Customer(counter);
        Protect protect = new Protect(counter);
        customer.start();
        protect.start();
    }
}

部分结果：

新增创建线程方式

实现Callable接口与使用Runnable相比，Callable功能更强大些.
• 相比run（）方法，可以有返回值
• 方法可以抛出异常
• 支持泛型的返回值
• 需要借助FutureTask类，获取返回结果
接收任务
FutureTask<Integer> futureTask = new FutureTask(任务);
创建线程
Thread t = new Thread(futureTask);
t.start();
Integer val = futureTask.get();获得线程call方法的返回值

线程：

import java.util.concurrent.Callable;

public class MyThread implements Callable<Integer> {
    int n = 0;
    @Override
    public Integer call() throws Exception {
        for (int i = 0; i <= 100; i++) {
            n += i;
        }
        return n;
    }
}

测试：

import java.util.concurrent.ExecutionException;
import java.util.concurrent.FutureTask;

public class Test {
    public static void main(String[] args) throws ExecutionException, InterruptedException {
        MyThread myThread = new MyThread();
        FutureTask<Integer> futureTask = new FutureTask(myThread);//借助 FutureTask类
        Thread thread = new Thread(futureTask);
        thread.start();
        Integer sum = futureTask.get();//得到返回值
        System.out.println(sum);
    }
}

小俱的一步步

关注

4
点赞
踩
0

收藏

觉得还不错? 一键收藏
打赏
1
评论
Java线程

多个线程同时读写同一份共享资源时，可能会引起冲突。所以引入线程“同步”机制，即各线程间要有先来后到；同步就是排队+锁：几个线程之间要排队，一个个对共享资源进行操作，而不是同时进行操作；为了保证数据在方法中被访问时的正确性，在访问时加入锁机制
复制链接

扫一扫