Thread线程知识小结

目录

1.程序、进程、线程

2.继承Thread类和实现Runnable接口的区别

3.常用方法

4.线程状态

5.多线程概述

6.简述多线程优缺点

7.线程何时会出现线程安全问题,如何解决?

8.synchronized(同步锁)关键字的用法,需要注意什么?

9.synchronized和Lock锁的区别?

10.线程通信

11.经典案例：生产者与消费者

12.新增创建线程方式（Callable接口）

---

1.程序、进程、线程

程序：就是为了完成特定功能，使用计算机编程语言写的静态代码。

进程：运行程序时，操作系统要把程序加载进内存，进程是操作系统分配资源的最小单位。 

 线程：隶属于进程，操作系统最小的任务调度单元。

2.继承Thread类和实现Runnable接口的区别

Thread	线程代码存放继承Thread子类run方法中。
Runnable	线程代码存在实现接口的类的run方法中。

 Runnable的好处:

1.避免了单继承的局限性。

2.多个线程可以共同处理同一份资源。

3.常用方法

方法名称	作用
void start()	启动线程
final String getName()	返回线程的名称
final void setPriority(int newPriority)	设置线程的优先级(默认为5，1最小，10最高)
final void join()	先暂停所处线程，等待所join()线程终止后，再正常执行
static Thread currentThread()	currentThread() 返回对当前正在执行的线程对象的引用
static void sleep(long millis)	让当前正在执行的线程休眠（暂停执行），休眠时间由（毫秒）指定
yield()	线程让步
setDaemon(boolean on)	设置守护线程，如果只剩下守护线程，虚拟机也将退出。

 4.线程状态

java线程的6种状态以及一个线程可以调用两次start()方法吗？_迷茫的羔羊羊的博客-CSDN博客

 5.多线程概述

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

6.简述多线程优缺点

优点：

1.提高cpu利用率

2.将复杂任务分成多个线程同时执行

3.提高响应速度

缺点：

1.占用内存

2.线程之间访问同一份资源时会有影响 

7.线程何时会出现线程安全问题,如何解决?

线程安全问题：多线程+同时访问同一份资源

线程同步:

并行：多个线程同一时间各自完成自己的任务。

并发：多个线程同一时间完成同一件任务，实际是一个个执行。比如：卖票、抢购 

解决:多线程同步(即排队+锁)

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

8.synchronized(同步锁)关键字的用法,需要注意什么?

1.synchronized可以修饰代码块也可以修饰方法

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

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

2.同步锁:得是唯一的对象，可以是任何对象，此对象来记录有没有线程进入同步代码块。

3.synchronized修饰非静态的方法时，锁对象是this。

4.synchronized修饰静态的方法时，锁对象是当前类的class对象(每一个类被加载到内存时，会为此类创建一个对应的class对象，用来获取信息)。

9.synchronized和Lock锁的区别?

synchronized:

1.可以修饰代码块，也可以修饰方法。

2.是一个关键字，是通过操作系统底层编译指令来操作的。

3.是隐式锁，自动加锁，当代码异常或者同步代码块完后自动解锁。

Lock：

1.只能修饰代码块

2.ReentrantLock是java.util.concurrent.Locks包下的一个类，是通过java代码实现的。

3.需要手动加锁和解锁。

10.线程通信

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

涉及三个方法:

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

注意:

wait（），notify（），notifyAll（）三个方法必须使用在同步代码块或同步方法中,而且必须通过锁对象来调用。

11.经典案例：生产者与消费者

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

counter(柜台)：

public class counter {
    int num = 1;
    public synchronized void add()  {
        if(num>0){
            try {
                this.wait();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }else {
            num++;
            System.out.println(Thread.currentThread().getName()+"生产出商品");
            this.notify();
        }
    }
    public synchronized void sub(){
        if(num>0){
            num--;
            System.out.println(Thread.currentThread().getName()+"销售出商品");
            this.notify();
        }else {
            try {
                this.wait();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }

    }
}

 consume(消费者):

public class consume extends Thread {
    counter c;

    public consume(counter c) {
        this.c = c;
    }

    @Override
    public void run() {
        while (true){
            c.sub();
        }
    }
}

product(生产者)：

public class product extends Thread{
    counter c;

    public product(counter c) {
        this.c = c;
    }

    @Override
    public void run() {
        while (true){
            c.add();
        }
    }
}

Test(测试类)：

public class Test {
    public static void main(String[] args) {
        counter c = new counter();
        new consume(c).start();
        new product(c).start();
    }
}

测试结果：

12.新增创建线程方式（Callable接口）

● 实现Callable接口与使用Runnable相比，Callable功能更强大些

 • 相比run（）方法，可以有返回值

 • 方法可以抛出异常

 • 支持泛型的返回值

 • 需要借助FutureTask类，获取返回结果

接收任务 FutureTask futureTask = new FutureTask(任务);

创建线程 Thread t = new Thread(futureTask);

t.start();

Integer val = futureTask.get();获得线程call方法的返回值

举例：

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

public class test {
    public static void main(String[] args) throws ExecutionException, InterruptedException {
        sum d = new sum();
        FutureTask<Integer> futureTask = new FutureTask<>(d);
        Thread thread  =new Thread(futureTask);
        thread.start();
        Integer integer = futureTask.get(); //获取返回值
        System.out.println(integer);
    }
}