浅谈Java中的线程-CSDN博客

本文链接：https://blog.csdn.net/wssjiayou/article/details/126272262

Java中的线程

讲线程之前首先要明白进程和线程的区别：

进程：是独立运行的程序，具有独立性和互斥性。

线程：具有抢占式运行和资源共享的特性。是进程中最小的基本单位。

并发和并行的区别：

并发：同时发生，轮流交替执行

并行：真正意义上的同时执行。

创建线程的两种方式：

1.将一个类声明为 Thread 的子类。在子类中重写 run 方法。用 start 来分配并启动子类的实例。

class 类名 extends Thread {
    @Override
    public void run () {
        
    }
}

2.创建一个类是声明实现Runnable 接口。分配类的实例，在创建 Thread 时作为参数传递，并启动。

class 类名 implements Runnable {
     @Override
    public void run () {
        
    }
}
public class Demo1 {
    public static void main(String[] args) {
        类名 对象名 = new 类名;
        //Thread(Runnable target)  参数是Runnable这个接口对象
        //分配一个新的 Thread对象。
        Thread thread = new Thread(对象名);
        thread.start();
}

线程下面的几个方法：

构造方法：

Thread();分配一个新的 Thread对象。  无参构造方法

Thread(Runnable target)分配一个新的 Thread对象。 有参构造

Thread(Runnable target, String name)分配一个新的 Thread对象。并起名字

线程方法：

static Thread       currentThread(); 返回的是对当前正在执行的线程对象的引用

String    getName(); 返回此线程的名称。

void     setName(String name); 将此线程的名称更改为等于参数 name 。

int      getPriority(); 返回此线程的优先级。

void      setPriority(int newPriority); 更改此线程的优先级。
设置优先并不一定优先，只是增加了执行的概率。最小值是1，最大值是10，默认的是5

static void     sleep(long millis)使当前正在执行的线程以指定的毫秒数暂停（暂时停止执行），具体取决于系统定时器和调度程序的精度和准确性。

线程的同步和锁：【重要】

为什么要进行线程的同步？

因为 Java是允许多线程的，当多个线程操作同一个资源的时候，会发生冲突，导致得到或者打印的数据不准确，所以加同步锁。

synchronized 是Java中的关键字，是一种同步锁。

1.修饰一个代码块，被修饰的代码块称为同步语句块，其作用的范围是大括号 { } 里面的代码，作用的对象是调用这个代码块的对象。

2.修饰一个方法，被修饰的方法称为同步方法，其作用的范围是整个方法，作用的对象是调用这个方法的对象。

3.修饰一个类，其作用的范围是整个类。作用的对象是这个类的所有对象。

注意：

在定义接口方法时不能使用synchronized关键字。

构造方法不能使用synchronized关键字，但可以使用synchronized代码块来进行同步。

工作原理：

当一个线程进入 synchronized 所修饰的地方时，synchronized 会立马锁住，其他线程在外面排队等候。

案例：

卖电影票：三个线程: 淘票票美团猫眼 100张票

package com.qfedu.c_sync;

class SaleTicket implements Runnable {
    //声明一个变量票
    //静态的变量和对象没有关系了
    private static int ticket = 100;
    @Override
    public void run() {
        //能不能对循环加锁？不能 因为循环加锁以后，还是一个线程循环完，没有任何意义
        while (true) {
            //if语句加了锁以后
            //就意味着只有一个线程进入到if语句
            //假如线程1进入if语句了，线程2和线程3就会等待
            //线程1打印50 并--  ticket变量为49
            //线程2抢到了49 sout(49) tiket--  48
            //其他线程再抢！！！
            //核心业务 加了锁，只让一个线程进入，操作完以后。锁释放掉
            //然后这三个线程再抢。还只能进一个，再操作核心业务
            synchronized (this) {
                if (ticket > 0) {
                    System.out.println(Thread.currentThread().getName() + "卖出了第" +                            ticket + "票"); 
                    ticket--;
                } else {
                    System.out.println("卖完了");
                    break;
                }
            }
        }

    }
}
public class Demo4 {
    public static void main(String[] args) {
        SaleTicket saleTicket = new SaleTicket();
        new Thread(saleTicket, "淘票票").start();
        new Thread(saleTicket, "美团").start();
        new Thread(saleTicket, "猫眼").start();
        
    }
}

Lock锁：

Lock锁，使用是手动获取锁和释放锁，比 synchronized 更加灵活；可中断的获取锁，超时获取锁。

基本用法：lock（）；方法进行上锁，unlock（）；方法进行解锁。

Lock是一个接口，由两个直接实现类：ReentrantLock（重入锁）和 ReentrantReadWriteLock（读写锁）

修饰符和类型	方法	描述
void	lock（）	获得锁
void	lockInterruptibly（）	获得锁可中断；会对在外面等待的线程调用threadX.interrupt()方法中断等待过程
boolean	try Lock（）	锁在空闲的才能获取锁，未获得锁不会等待
boolean	try Lock（long time，TimeUnit unit ）	如果锁可用，则此方法返回true.如果锁不可用，当前线程将被禁用以进行线程调度。
void	unlock（）	释放锁