栏目分类:
子分类:
返回
名师互学网用户登录
快速导航关闭
当前搜索
当前分类
子分类
实用工具
热门搜索
名师互学网 > IT > 软件开发 > 后端开发 > Java

Java多线程基础学习笔记

Java 更新时间: 发布时间: IT归档 最新发布 模块sitemap 名妆网 法律咨询 聚返吧 英语巴士网 伯小乐 网商动力

Java多线程基础学习笔记

多线程 1、线程、进程、多线程 1.1、进程(process):

就是应⽤程序在内存中分配的空间,也就是正在运⾏的程序,各个进程之间互 不⼲扰。同时进程保存着程序每⼀个时刻运⾏的状态。

1.2、线程(Thread):

⼀个线程执⾏⼀个⼦任务,这样⼀个进程就包含了多个线程,每个线程负责⼀个单独的⼦任

务。

1.3、多线程:

进程让操作系统的并发性 成为了可能,⽽线程让进程的内部并发成为了可能。

多进程的⽅式也可以实现并发,为什么我们要使⽤多线程?

  • 进程间的通信⽐较复杂,⽽线程间的通信⽐较简单,通常情况下,我们需要使 ⽤共享资源,这些资源在线程间的通信⽐较容易。
  • 进程是重量级的,⽽线程是轻量级的,故多线程⽅式的系统开销更⼩。
1.4、进程和线程的区别

进程是⼀个独⽴的运⾏环境,⽽线程是在进程中执⾏的⼀个任务。他们两个本质的

区别是是否单独占有内存地址空间及其它系统资源(⽐如I/O):

  • 进程单独占有⼀定的内存地址空间,进程间存在内存隔离,数据是分开 的,数据共享复杂但是同步简单,各个进程之间互不⼲扰;⽽线程共享所属进程占有的内存地址空间和资源,数据共享简单,但是同步复杂。
  • 进程单独占有⼀定的内存地址空间,⼀个进程出现问题不会影响其他进程,不影响主程序的稳定性,可靠性⾼;⼀个线程崩溃可能影响整个程序的稳定性,可靠性较低。
  • 进程单独占有⼀定的内存地址空间,进程的创建和销毁不仅需要保存寄存器和栈信息,还需要资源的分配回收以及⻚调度,开销较⼤;线程只需要保存寄存器和栈信息,开销较⼩。
2、线程的创建

继承Thread(重点)、实现Runnable接口(重点)、实现Callable接口

2.1、Thread类
public class MyThread extends Thread{
    @Override
    public void run() {
        for (int i = 0; i < 20; i++) {
            System.out.println("我在上路...."+ i);
        }
    }
    public static void main(String[] args) {
        MyThread thread  = new MyThread();
        thread.start();
        for (int i = 0; i < 2000; i++) {
            System.out.println("我在下路...."+ i);
        }
    }
}
//调用start方法之后,线程才算启动

我在上路…0
我在下路…0
我在上路…1
我在下路…1
我在上路…2
我在下路…2
我在上路…3

练习Thread,实现多线程同步下载图片

package com.czb.xkk;

import org.apache.commons.io.FileUtils;

import java.io.File;
import java.io.IOException;
import java.net.URL;

public class MyThread2 extends Thread{
    private String url;  //网络图片地址
    private String name; //保存文件夹
    @Override
    public void run() {
    WebDownloder webDownloder = new WebDownloder();
    webDownloder.downloder(url,name);
    System.out.println("下载了文件名为:"+name);
    }
    public MyThread2(String name, String url) {
        this.url = url;
        this.name = name;
    }
    public static void main(String[] args) {
       MyThread2 T1 = new MyThread2("阿尼亚1.jpg","https://biaoqingba.cn/wp-content/uploads/2022/05/c7cc5fa906fc7b1.jpeg");
        MyThread2 T2 = new MyThread2("阿尼亚2.jpg","https://biaoqingba.cn/wp-content/uploads/2022/05/c7cc5fa906fc7b1.jpeg");
        MyThread2 T3 = new MyThread2("阿尼亚3.jpg","https://biaoqingba.cn/wp-content/uploads/2022/05/c7cc5fa906fc7b1.jpeg");
       T1.start();
       T2.start();
       T3.start();
    }
}
class WebDownloder{
    //下载方法
    public void downloder(String url,String name){
        try {
            FileUtils.copyURLToFile(new URL(url),new File(name));
        } catch (IOException e) {
            e.printStackTrace();
            System.out.println("IO异常,downloder方法出现问题");
        }
    }
}

下载了文件名为:阿尼亚2.jpg
下载了文件名为:阿尼亚1.jpg
下载了文件名为:阿尼亚3.jpg

2.2、实现Runnable接口(推荐)

避免单继承局限性,灵活方便,方便多个线程操作同一个对象

package com.czb.xkk;
public class MyThread3 implements Runnable{
    @Override
    public void run()
    {
        for (int i = 0; i < 20; i++) {
            System.out.println("run方法"+ i);
        }
    }
    public static void main(String[] args) {
        new Thread(new MyThread3()).start();//和继承Thread类主要的不同点
        for (int i = 0; i < 200; i++) {
            System.out.println("main方法"+ i);
        }
    }
}
修改上面代码利用实现Runnable方法下载图片:
        new Thread(T1).start();
        new Thread(T2).start();
        new Thread(T3).start();
package com.czb.xkk;
//经典抢票问题
public class MyThread4 implements Runnable{
    private int tickets = 1;
    @Override
    public void run() {
        while(true){
            if(tickets>=100){
                break;
            }
            tickets++;
            //获取当前线程名字
            System.out.println(Thread.currentThread().getName()+"拿到了第"+tickets +"票");
        }
    }
    public static void main(String[] args) {
        MyThread4 myThread4 = new MyThread4();
        new Thread(myThread4,"小明").start();//三个线程
        new Thread(myThread4,"小红").start();
        new Thread(myThread4,"黄牛").start();
    }
}
//出现了线程安全问题
黄牛拿到了第4票
小明拿到了第4票
小红拿到了第4票
黄牛拿到了第5票
小明拿到了第6票
小红拿到了第7票
小明拿到了第8票
2.3、实现Callable接口
//方式一:使用线程池的方式
//需要返回值
public class TestCallable implements Callable {}
//重写call方法
//创建执行服务
//可以抛异常
 ExecutorService ser = Executors.newFixedThreadPool(3);
 //提交执行
 Future result1 = ser.submit(T1);
 Future result2 = ser.submit(T2);
 Future result3 = ser.submit(T3);
//获取结果
 boolean r1 = result1.get();
 boolean r2 = result2.get();
 boolean r3 = result3.get();
 //关闭服务
 ser.shutdownNow();


//方式二:使用FutureTask执行
FutureTask futuretask= new FutureTask(T1);
FutureTask futuretask1= new FutureTask(T2);
FutureTask futuretask2= new FutureTask(T3);
new Thread(futuretask).start();
new Thread(futuretask1).start();
new Thread(futuretask2).start();
//可以通过futuretask得到运行结果
futuretask.get();
3、静态代理模式
//层层调用,真实对象和代理对象实现同一个接口
//好处
//代理对象可以做真实对象做不了的事情,
//真实对象专注自己的事情
package com.czb.xkk.Proxy;
public class StaticProxy {
    public static void main(String[] args) {
        new proxy(new you()).HappyMarry();
    }
}
interface Marry{
    void HappyMarry();
}
//真实角色
class you implements Marry{
    @Override
    public void HappyMarry() {
        System.out.println("我们要结婚啦!");
    }
}
class proxy implements Marry{
    private Marry target;
    //代理--》真实对象
    public proxy(Marry target) {
        this.target = target;
    }
    @Override
    public void HappyMarry() {
        before();
        this.target.HappyMarry();
        after();
    }
    private void after() {
        System.out.println("洞房花烛!");
    }
    private void before() {
        System.out.println("布置婚房!");
    }
}
4、Lamda表达式

函数式接口的定义:

  • 任何接口,如果只包含唯一一个抽象方法,那么它就是一个函数式接口。

比如:

public interface Runnable{
	public abstract void run();
}
  • 对于函数式接口,可以通过lamda表达式来创建该接口的对象。
package com.czb.xkk.TestLamda;
//层层简化
public class Teat1 {
    //1、静态内部类
    static class Like2 implements iLike{
        @Override
        public void lamda() {
            System.out.println("我爱lamda2");
        }
    }
    public static void main(String[] args) {
       iLike like;
       new Like().lamda();
       like.lamda();
       //2、局部内部类
        class Like3 implements iLike{
            @Override
            public void lamda() {
                System.out.println("我爱lamda3");
            }
        }
        new Like3().lamda();
        //3、匿名内部类,没有类名只能借助接口名或者父类实现
      new iLike(){
            @Override
            public void lamda() {
                System.out.println("我爱lamda4");
            }
        }.lamda();
      //4、lamda简化,iLike只有一个方法
       iLike like = ()->{
            System.out.println("我爱lamda5");
        };
        like.lamda();
    }
}
interface iLike{
    void lamda();
}
class Like implements iLike{
    @Override
    public void lamda() {
        System.out.println("我爱lamda");
    }
}



//简化模式,不需要实现类,直接使用接口
package com.czb.xkk.TestLamda;

public class Teat1 {
    public static void main(String[] args) {
        iLike like;
        //简化1,参数类型
        like = (a)->{
            System.out.println("我爱lamda5"+a);
        };
        like.lamda();
        //简化2,去掉括号,没有参数不能去括号
         like = a->{
            System.out.println("我爱lamda5"+a);
        };
        like.lamda(521);
        //简化3,去掉大括号,只适用于大括号里面只有一行代码的情况
         like = a->System.out.println("我爱lamda5"+a);
        like.lamda(521);
    }
}
interface iLike{
    void lamda(int a);
}
5、对线程的操作 5.1、线程停止

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-PfK2jb3d-1655867474087)(C:UsersDIYAppDataRoamingTyporatypora-user-imagesimage-20220621151205012.png)]

方法:

setPriority(int newPriority)   //更改线程优先级
static void sleep(long mills)  //线程休眠
    Thread.sleep(200);
void join()                   //等待该线程终止
static void yield()           //暂停执行当前线程,并执行其他线程
void interrupt()              //中断线程,不要使用
boolean isAlive()             //测试线程是否处于活动状态
package com.czb.xkk.ThreadMethod;

public class TestStop implements Runnable{
    private  Boolean flag = true;
    @Override
    public void run() {
        int i = 0;
        while(flag){
            System.out.println("Thread..."+i++);
        }
    }
    public void stop(){
        this.flag = false;
    }
    public static void main(String[] args) {
        TestStop testStop = new TestStop();
        new Thread(testStop).start();
        for (int i = 0; i < 1000; i++) {
            System.out.println("线程"+i);
            if(i==888){
                testStop.stop();
                System.out.println("分线程停止"+i);//TestStop线程停止,主线程继续运行
            }
        }
    }
}
5.2、线程休眠
package com.czb.xkk.ThreadMethod;

public class TestSleep {
    public static void tenDown() throws InterruptedException {
        int time = 10;
        while (true){
                Thread.sleep(1000);
                 System.out.println(time--);
                if(time<=0){break;}
        }
    }
    public static void main(String[] args) {
        try {
            tenDown();
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }
}

5.3、线程暂停yield
package com.czb.xkk.ThreadMethod;

import com.czb.xkk.MyThread;
public class TestYield {
    public static void main(String[] args) {
        MyYield myYield = new MyYield();
        Thread thread = new Thread(myYield,"a");
        Thread thread2 = new Thread(myYield,"b");
        thread.start();
        thread2.start();
    }
}
class MyYield implements Runnable{
    @Override
    public void run() {
        System.out.println(Thread.currentThread().getName()+"线程正在执行");
        Thread.yield();//礼让,不一定成功
        System.out.println(Thread.currentThread().getName()+"线程正在执行");
    }
}
a线程正在执行
b线程正在执行
a线程正在执行
b线程正在执行
5.4、线程强制执行
package com.czb.xkk.ThreadMethod;

public class JoinTest implements Runnable{
    @Override
    public void run() {
        for (int i = 0; i < 1000; i++) {
            System.out.println("vip来啦"+i);
        }
    }

    public static void main(String[] args) throws InterruptedException {
        JoinTest joinTest = new JoinTest();
        Thread thread = new Thread(joinTest);
        thread.start();
        for (int i = 0; i < 100; i++) {
            if(i==66){
                thread.join();//JoinTest分线程执行,待分线程执行结束才会执行main线程
            }
            System.out.println("main"+i);
        }
    }
}
5.5、线程状态
  • **初始(NEW):**新创建了一个线程对象,但还没有调用start()方法。

  • **运行(RUNNABLE):**Java线程中将就绪(ready)和运行中(running)两种状态笼统的称为“运行”。线程对象创建后,其他线程(比如main线程)调用了该对象的start()方法。该状态的线程位于可运行线程池中,等待被线程调度选中,获取CPU的使用权,此时处于就绪状态(ready)。就绪状态的线程在获得CPU时间片后变为运行中状态(running)。

  • **阻塞(BLOCKED):**表示线程阻塞于锁。

  • **等待(WAITING):**进入该状态的线程需要等待其他线程做出一些特定动作(通知或中断)。

  • **超时等待(TIMED_WAITING):**该状态不同于WAITING,它可以在指定的时间后自行返回。终止(TERMINATED):表示该线程已经执行完毕。

  • package com.czb.xkk.ThreadMethod;
    public class TestState {
        public static void main(String[] args) throws InterruptedException {
            Thread thread = new Thread(()->{
                for (int i = 0; i < 10; i++) {
                    try {
                        Thread.sleep(1000);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }
            });
            System.out.println(thread.getState());//new
            thread.start();
            System.out.println(thread.getState());//run
            while(thread.getState()!=Thread.State.TERMINATED){
                Thread.sleep(100);
                System.out.println(thread.getState());//TIMED_WATTING、TERMINATED一旦进入死亡状态就不能再次启动了
            }
        }
    }
    
5.6、线程优先级

优先级用数字表示,范围从1-10,优先级较高不一定会优先执行

//三个常量
Thread.MIN_PRIORITY = 1;
Thread.MAX_PRIORITY = 10;
Thread.NORM_PRIORITY = 5;
//方法
getPriority();
setPriority();
package com.czb.xkk.ThreadMethod;

public class TestPriority {
    public static void main(String[] args) {
        System.out.println(Thread.currentThread().getName()+"优先级为"+Thread.currentThread().getPriority());
        MyPriority myPriority = new MyPriority();
        Thread T1 = new Thread(myPriority);
        Thread T2 = new Thread(myPriority);
        Thread T3 = new Thread(myPriority);
        Thread T4 = new Thread(myPriority);
        T2.setPriority(1);
        T3.setPriority(4);
        T4.setPriority(Thread.MAX_PRIORITY);
        T1.start();
        T2.start();
        T3.start();
        T4.start();
    }
}
class MyPriority implements Runnable{
    @Override
    public void run() {
        System.out.println(Thread.currentThread().getName()+"优先级为"+Thread.currentThread().getPriority());
    }
}
6、线程安全问题

**并发:**同一个对象被多个线程同时操作。

线程同步(synchronized)实际是一种等待机制。

不安全的例子:经典抢票问题!银行取款问题!

6.1、同步方法:
  • synchronized关键字,包括synchronized方法和synchronized块。
//同步方法,给每个对象加了一把锁
public synchronized void method(){}
//缺点:影响效率
  • 同步块:

    synchronized(obj){}
    //obj称为同步监视器,可以为任何对象
    //同步方法无需指定同步监视器
    
//同步方法
public class SafeTd {
    public static void main(String[] args) {
        BuyTickets buyTickets = new BuyTickets();
        Thread t1 = new Thread(buyTickets,"小明");
        Thread t2 = new Thread(buyTickets,"小红");
        Thread t3 = new Thread(buyTickets,"黄牛");
        t1.start();
        t2.start();
        t3.start();
    }
}
class  BuyTickets implements Runnable{
    private int tickets = 100;
    @Override
    public synchronized void run() {  //在买票方法中添加synchronized关键字,实现同步
            while(true){
                if(tickets<=0){
                    break;
                }
            System.out.println(Thread.currentThread().getName()+"买到了第"+tickets--+"张票");
            }
    }
}
//同步块
class  BuyTickets implements Runnable{
    private int tickets = 100;
    Object obj = new Object();
    @Override
    public void run() {
        synchronized (obj){
            while(true){
                if(tickets<=0){
                    break;
                }
                System.out.println(Thread.currentThread().getName()+"买到了第"+tickets--+"张票");
            }
        }
    }
}
6.2、死锁

指两个线程或多个线程都在等待对方释放资源而停止执行的情况。某一个同步块同时拥有“两个以上对象的锁”时,就有可能产生“死锁”现象。

package com.czb.xkk.SafeThread;

public class DeadLock {
    public static void main(String[] args) {
        Makeup makeup = new Makeup(0,"灰姑娘");
        Makeup makeup1 = new Makeup(1,"白雪公主");
        makeup.start();
        makeup1.start();
    }
}
class LipStick{

}
class Mirror{

}
class Makeup extends Thread{
    static LipStick lipStick = new LipStick();
    static Mirror mirror = new Mirror();
    int choice;
    String girlName;
    Makeup(int choice,String girlName){
        this.choice = choice;
        this.girlName = girlName;
    }
    @Override
    public void run() {
        try {
            makeup();
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }
    private void makeup() throws InterruptedException {
        if(choice==0){
            synchronized (lipStick){
                System.out.println(this.girlName+"获得口红");
                Thread.sleep(1000);
                synchronized (mirror){
                    System.out.println(this.girlName+"获得镜子");
                }
            }
        }else{
            synchronized (mirror){
                System.out.println(this.girlName+"获得镜子");
                Thread.sleep(2000);
                synchronized (lipStick){
                    System.out.println(this.girlName+"获得口红");
                }
            }
        }
     }
 }
灰姑娘获得口红
白雪公主获得镜子
出现死锁现象
解决方法:
 synchronized (mirror){
    System.out.println(this.girlName+"获得镜子");
        }
放到上一个锁的外面,保证一个代码块只有一把锁。
灰姑娘获得口红
白雪公主获得镜子
白雪公主获得口红
灰姑娘获得镜子
6.3、Lock锁

ReentrantLock类实现了Lock,它拥有与synchronized相同的并发性和内存语义,在实现线程安全的控制中,比较常用的是ReentrantLock,可以显式加锁、释放锁。(可重入锁)

package com.czb.xkk;

import java.util.concurrent.locks.ReentrantLock;

public class TestLock {
    public static void main(String[] args) {
          TestLock2 testLock2 = new TestLock2();
          new Thread(testLock2,"李华").start();
          new Thread(testLock2,"黄牛").start();
    }
}
class TestLock2 implements Runnable{
     private int tickets = 10;
    //定义Lock锁
    private final ReentrantLock lock = new ReentrantLock();
    @Override
    public void run() {
        lock.lock();
           try{
             while (true) {
               if (tickets <= 0) {
                      break;
              } else {
               System.out.println(Thread.currentThread().getName() + "获得了第" + tickets-- + "张票");
                    }
                }
            }finally{
               lock.unlock();//解锁
           }
      }
}
出现的问题:
    new了两个TestLock2类的变量
    TestLock2 testLock1 = new TestLock2();
    TestLock2 testLock2 = new TestLock2();
    new Thread(testLock1,"李华").start();
    new Thread(testLock2,"黄牛").start(); 
导致还会出现线程安全问题。
6.4、线程协作 6.4.1、线程之间通信的方法:
方法名作用
wait()表示线程一直等待,直到其他线程通知,与sleep不同,wait会释放锁
wait(long timeout)指定等待的毫秒数
notify()唤醒一个处于等待的线程
notifyAll唤醒同一个线程上所有的调用了wait()方法的线程,优先级高的线程优先调度

注意:以上都是Object类的方法,都只能在同步方法或者同步代码块中使用,否则会抛出异常。

6.4.2、并发的消费者生产者模式: 解决方法一:

管程法:加入缓冲区,生产者将数据放入缓冲区,消费者从缓冲区拿出数据。

package com.czb.xkk;

import java.awt.*;
//测试生产者消费者问题1:管程法,加入缓冲区
public class ProductConsumer {
    public static void main(String[] args) {
        SynContainer container = new SynContainer();
        new Product(container).start();
        new Consumer(container).start();
    }
}
class Product extends Thread{
    SynContainer container;
    public Product(SynContainer container) {
            this.container = container;
    }
    @Override
    public void run() {
        for (int i = 1; i < 100; i++) {
            System.out.println("生产了"+ i +"只鸡");
            container.push(new Chicken(i));
        }
    }
}
class Consumer extends  Thread{
    SynContainer container;
    public Consumer(SynContainer container) {
        this.container = container;
    }
    @Override
    public void run() {
        for (int i = 1; i < 100; i++) {
            System.out.println("消费了"+container.pop().id+"只鸡");
            container.pop();
        }
    }
}
class Chicken {
    int id;
    public Chicken(int id) {
        this.id = id;
    }
}

class SynContainer{
        Chicken [] chickens=new Chicken[10];
        int count=0;
        //生产者生产
        public synchronized void push(Chicken chicken) {
            while (count == chickens.length) {
                try {
                    //生产满了,生产等待
                    this.wait();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
            //没满就继续生产
            chickens[count] = chicken;
            count++;
            //唤醒当前等待的线程,通知消费者消费
            this.notifyAll();
        }
        //消费者消费
        public synchronized Chicken pop() {
            while (count == 0) {
                try {
                    //产品空缺,消费等待
                    this.wait();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
            //存在产品,继续消费
            count--;
            Chicken chicken = chickens[count];
            //通知生产者生产
            this.notifyAll();
            return chicken;
        }
    }
解决方法二:
package com.czb.xkk;

//测试生产者消费者问题2:信号灯法,通过标志位解决
public class Test{
        public static void main(String[] args) {
            TV tv = new TV();
            new Player(tv).start();
            new Watcher(tv).start();
        }
    }
    //生产者-->演员
class Player extends Thread {
        TV tv;
        public Player(TV tv) {
            this.tv = tv;
        }
        @Override
        public void run() {
            for (int i = 0; i < 20; i++) {
                if (i % 2 == 0) {
                    this.tv.play("胸口碎大石");
                } else {
                    this.tv.play("借尸还魂");
                }
            }
        }
    }
    //消费者-->观众
  class Watcher extends Thread {
        TV tv;
        public Watcher(TV tv) {
            this.tv = tv;
        }
        @Override
        public void run() {
            for (int i = 0; i < 20; i++) {
                tv.watch();
            }
        }
    }
    //产品-->节目
class TV {
        //演员表演,观众等待 T
        //观众观看,演员等待 F
        String voice; // 表演的节目
        boolean flag = true;
        //表演
    public synchronized void play(String voice) {
            if (!flag) {
                try {
                    this.wait();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
            System.out.println("演员表演了:" + voice);
            //通知观众观看
            this.notifyAll();
            this.voice = voice;
            this.flag = !this.flag;
        }
        //观看
   public synchronized void watch() {
            if (flag) {
                try {
                    this.wait();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
            System.out.println("观看了:" + voice);
            //通知演员表演
            this.notifyAll();
            this.flag = !this.flag;
        }
    }
6.5、线程池

在并发的情况下,会提升性能,便于线程管理。

线程池接口:ExecutorService

package com.czb.xkk;

import java.util.concurrent.Executor;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;

public class TestPool {
    public static void main(String[] args) {
        //创建线程池
        ExecutorService service = Executors.newFixedThreadPool(10);
        //执行
        service.execute(new MyThread1());
        service.execute(new MyThread1());
        service.execute(new MyThread1());
        //关闭连接
        service.shutdown();
    }
}
class MyThread1 implements Runnable{
    @Override
    public void run() {
        System.out.println(Thread.currentThread().getName());
    }
}
pool-1-thread-1
pool-1-thread-3
pool-1-thread-2

要是世界也这么简单就好了!

转载请注明:文章转载自 www.mshxw.com
本文地址:https://www.mshxw.com/it/985726.html
我们一直用心在做
关于我们 文章归档 网站地图 联系我们

版权所有 (c)2021-2022 MSHXW.COM

ICP备案号:晋ICP备2021003244-6号