Java多线程

一.线程简介

1.1多任务 多线程(多条执行路径,主线程和子线程并行交替执行)

1.2程序.进程(process).线程(Thread)

1)进程则是执行程序的一次执行过程,是一个动态的概念,是系统资源分配的单位

2)一个进程中可以包含若干个线程,当然一个进程中至少有一个线程,线程是CPU调度和执行的单位

tips:真正的多线程是指有多个CPU,即多核,如服务器

3)线程就是独立的执行路径

4)在程序运行时,即使没有创建线程,后台也会有多个线程,如主线程,gc线程

5)main称为主线程,为系统的入口,用于执行整个程序

6)对同一份资源操作时,会存在资源抢夺的问题,需要加入并发装置

7)线程会带来额外的开销,如CPU调度时间,并发控制开销

8)每个线程在自己的工作内存交互,内存控制不当造成数据不一致

二.线程创建

2.1 三种创建方式

1.Tread class(继承Thread类) 

2.Runnable(实现Runnable接口)

3.Callable(实现Callable接口)

2.1.1 继承Thread类

1.自定义线程类继承Thread类

2.重写run()方法,编写线程执行体

3.创建线程对象,调用start()方法启动线程

tips:

1.子类继承Thread类具备多线程能力

2.启动线程:子类对象.start

3.不建议使用:避免OOP单继承局限性

package Demo01;
//创建线程方式一:继承thread类,重写run()方法,调用start开启线程
//线程开启不一定立即执行 由CPU调度
public class TestThread1 extends Thread{
    @Override
    public void run() {
        //run方法线程体
        for(int i=0;i<20;i++){
            System.out.println("我在看代码"+i);
        }
    }

    public static void main(String[] args) {
        //main线程,主线程
        //创建一个线程对象
        TestThread1 testThread1 = new TestThread1();
        //调用start()方法 开启线程
        testThread1.start();//多线程在前 代码在后 当i<1000 发现是交替执行 中间穿插
        testThread1.run();//代码在前 多线程在后
        for(int i=0;i<20;i++){
            System.out.println("我在学习多线程"+i);
        }
    }
}

 

package Demo01;

import org.apache.commons.io.FileUtils;

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

//实现多线程同步下载图片
public class TestThread02 extends Thread {
    private String url;//网络图片地址
    private String name;//保存的文件名
    //手写一个构造器
    public TestThread02(String url,String name){
        this.url = url;
        this.name = name;
    }

    public TestThread02() {

    }
//下载图片的执行体
    @Override
    public void run() {
        WebDownloader webDownloader = new WebDownloader();
        webDownloader.downloader(url,name);
        System.out.println("文件名为"+name);
    }

    public static void main(String[] args) {
        TestThread02 t1= new TestThread02("https://t7.baidu.com/it/u=4256280520,1252070511&fm=193&f=GIF","1.jpg");
        TestThread02 t2= new TestThread02("https://t7.baidu.com/it/u=4256280520,1252070511&fm=193&f=GIF","2.jpg");
        TestThread02 t3= new TestThread02("https://t7.baidu.com/it/u=4256280520,1252070511&fm=193&f=GIF","3.jpg");
        t1.start();/*文件名为1.jpg
                    文件名为3.jpg
                     文件名为2.jpg 下载顺序*/
        t2.start();
        t3.start();
    }
}


//下载器
class WebDownloader{
    //下载方法
    public void downloader(String url,String name) {
        try {
            FileUtils.copyURLToFile(new URL(url),new File(name));
        } catch (IOException e) {
           e.printStackTrace();
            System.out.println("IO异常,downloder方法出现问题");
        }
    }
}

2.2.1 实现Runnable 

 1.定义Runnable类实现Runnable接口

2.实现run()方法,编写线程执行体

3.创建线程对象,调用start()方法启动线程

tips:

1.实现接口Runnable具有多线程能力

2.启动线程:传入目标对象+Thread对象.start

3.推荐使用:避免单继承局限性,灵活方便,方便同一个对象被多个线程使用

package Demo01;

public class TestThread3 implements Runnable{
    @Override
    public void run() {
        //run方法线程体
        for(int i=0;i<200;i++){
            System.out.println("我在看代码"+i);
        }
    }

    public static void main(String[] args) {
        //main线程,主线程
        //创建实现类对象
        TestThread3 testThread3 = new TestThread3();
        //创建线程对象
      //  Thread thread = new Thread(testThread3);
      //  thread.start();
        new Thread(testThread3).start();//上两句综合成一句
        for(int i=0;i<1000;i++){
            System.out.println("我在学习多线程"+i);
        }
    }
}
package Demo01;

import org.apache.commons.io.FileUtils;

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

//实现多线程同步下载图片
public class TestThread02 implements Runnable{
    private String url;//网络图片地址
    private String name;//保存的文件名
    //手写一个构造器
    public TestThread02(String url,String name){
        this.url = url;
        this.name = name;
    }

    public TestThread02() {

    }
//下载图片的执行体
    @Override
    public void run() {
        WebDownloader webDownloader = new WebDownloader();
        webDownloader.downloader(url,name);
        System.out.println("文件名为"+name);
    }

    public static void main(String[] args) {
        TestThread02 t1= new TestThread02("https://t7.baidu.com/it/u=4256280520,1252070511&fm=193&f=GIF","1.jpg");
        TestThread02 t2= new TestThread02("https://t7.baidu.com/it/u=4256280520,1252070511&fm=193&f=GIF","2.jpg");
        TestThread02 t3= new TestThread02("https://t7.baidu.com/it/u=4256280520,1252070511&fm=193&f=GIF","3.jpg");
       new Thread(t1).start();
        new Thread(t2).start();
        new Thread(t3).start();
    }
}


//下载器
class WebDownloader{
    //下载方法
    public void downloader(String url,String name) {
        try {
            FileUtils.copyURLToFile(new URL(url),new File(name));
        } catch (IOException e) {
           e.printStackTrace();
            System.out.println("IO异常,downloder方法出现问题");
        }
    }
}
package Demo01;

import org.apache.commons.io.FileUtils;

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

//多个线程操作同一个对象
//买火车票的接口
//多个线程操作同一个资源的情况下,线程不安全,数据紊乱
public class TestThread4 implements Runnable {

    //票数
    private int ticketnumbers = 10;


    @Override
    public void run() {
        while (true) {
            if (ticketnumbers <= 0) {
                break;
            }
            //模拟延时
            try {
                Thread.sleep(500);
            }catch (InterruptedException e){
                e.printStackTrace();
            }
            System.out.println(Thread.currentThread().getName() + "拿到了第" + ticketnumbers + "票");//可以知道是谁拿的
        }
    }

    public static void main(String[] args) {
        TestThread4 ticket = new TestThread4();

        new Thread(ticket,"P").start();
        new Thread(ticket,"L").start();
        new Thread(ticket,"Y").start();

    }
}

 2.3.1 实现Callable接口

1.实现Callable接口,需要返回值类型

2.重写call方法,需要抛出异常

3.创建目标对象

4.创建执行任务:ExecutorService ser = Executors.newFixedThreadPool(1);

5.提交执行:Future<Boolean>result1 = ser.submit(t1);

6.获取结果:boolean r1 = result1.get()

7.关闭服务:ser.shutdownNow();

package Demo02;

import Demo01.TestThread02;
import com.sun.corba.se.impl.orbutil.closure.Future;
import org.apache.commons.io.FileUtils;

import java.io.File;
import java.io.IOException;
import java.net.URL;
import java.util.concurrent.Callable;
import java.util.concurrent.ExecutorCompletionService;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;

public class TestCallable implements Callable {
    private String url;//网络图片地址
    private String name;//保存的文件名
    //手写一个构造器
    public TestCallable(String url,String name){
        this.url = url;
        this.name = name;
    }
    
    //下载图片的执行体
    @Override
    public Boolean call() {
       WebDownloader webDownloader = new WebDownloader();
        webDownloader.downloader(url,name);
        System.out.println("文件名为"+name);
        return true;
    }

    public static void main(String[] args) {
        TestThread02 t1= new TestThread02("https://t7.baidu.com/it/u=4256280520,1252070511&fm=193&f=GIF","1.jpg");
        TestThread02 t2= new TestThread02("https://t7.baidu.com/it/u=4256280520,1252070511&fm=193&f=GIF","2.jpg");
        TestThread02 t3= new TestThread02("https://t7.baidu.com/it/u=4256280520,1252070511&fm=193&f=GIF","3.jpg");
        ExecutorService ser = Executors.newFixedThreadPool(3);
        Future <boolean> result = ser.submit(t1);
        boolean rs1 = r1.get();
        ser.shutdownNow();
    }
}


//下载器
class WebDownloader{
    //下载方法
    public void downloader(String url,String name) {
        try {
            FileUtils.copyURLToFile(new URL(url),new File(name));
        } catch (IOException e) {
            e.printStackTrace();
            System.out.println("IO异常,downloder方法出现问题");
        }
    }
    
}

三.静态代理 

 

//真实对象和代理对象都要实现同一个接口
//代理对象需要代理真实角色
//代理对象做很多真实对象做不了的事

public class StaticProxy {
    public static void main(String[] args) {
        WeddingCompany weddingCompany = new WeddingCompany(new You());
        weddingCompany.HappyMarry();
    }
}
interface Marry{
    void HappyMarry();
}
//真实角色 你去结婚
class You implements Marry{

    @Override
    public void HappyMarry() {
        System.out.println("happy");
    }
}
//代理角色 帮助你结婚
class WeddingCompany implements Marry{
       private Marry target;

    WeddingCompany(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("收尾款");
    }
}

四.Lamda表达式 

1.避免匿名内部类定义过多

2.让代码更简洁

package lambda;

public class TestLambda01 {
    //静态内部类
  static  class Like2 implements ILike{
        @Override
        public void Lambda() {
            System.out.println("I like B2");
        }
    }
    public static void main(String[] args) {
        ILike like = new Like();
        like.Lambda();
        like = new Like2();
        like.Lambda();
        //局部内部类
        class Like3 implements ILike{
            @Override
            public void Lambda() {
                System.out.println("I like B3");
            }
        }
        like = new Like3();
        like.Lambda();
        //匿名内部类 没有类的名称 需要借助父类或接口
        like = new ILike() {
            @Override
            public void Lambda() {
                System.out.println("I like B4");
            }
        };
        like.Lambda();
        //用lambda简化
        like = ()->{
            System.out.println("I like B5");
        };
        like.Lambda();
    }
}
//定义1个函数式接口
interface ILike{
    void Lambda();
}
//实现类
class Like implements ILike{
    @Override
    public void Lambda() {
        System.out.println("I like B");
    }
}
package lambda;

public class TestLambda02 {

    public static void main(String[] args) {
                ILove love= love (int a)->{
                System.out.println("I Love You1"+a);
            };
                //1 参数类型
        love =(a) ->{
            System.out.println("I Love You1"+a);
        };
        //2 简化括号
        love = a->{
            System.out.println("I Love You1"+a);
        };
        //3 去掉花括号
        love = a-> System.out.println("I Love You1"+a);
        //总结
        //lambda表达式只能有一行代码的情况下 才能简化为一行 如果有多行 那么用代码块包裹
        //前提是接口为函数式接口
        
                
        love.love(20);
        }
}
interface ILove{
    void love(int a);
}

五.线程状态 

5.1 五大状态

1.创建状态(线程对象一旦创建就进入新生状态)

2.就绪状态(当调用start()方法 线程立即进入就绪状态 但并不意味着立即调度执行)

3.运行状态(进入此状态 线程才真正执行线程体的代码块)

4.阻塞状态(当调用sleep wait或同步锁定时,线程进入阻塞状态,就是代码不往下执行,阻塞事件解除 重新进入就绪状态 等待CPU调度)

5.死亡状态 (线程中断或者结束 一旦进入死亡状态 就不能再次启动)

5.2 线程方法

setPriority(int newPriority):更改现成的优先级

static void sleep(long millis):在指定的毫秒数内让当前正在执行的线程休眠

void join():等待该线程终止

static void yield():暂停当前正在执行的线程对象,并执行其他线程

void interrupt():中断线程,不用这个方式

boolean isAlive():测试线程是否处于活动状态

5.3 线程停止

1.建议使用一个标志位进行终止变量,当flag = false,则终止线程运行

package state;
//测试stop
//建议线程正常停止 利用次数 不建议死循环
//建议使用标志位 设置一个标志位
//不要使用stop或destroy等过时或者JDK不建议使用的方法
public class TestStop implements Runnable {
    //1.设置一个标志位
    private boolean flag = true;

    @Override
    public void run() {
        int i=0;
        while(flag){
            System.out.println("run....Thread"+i++);
        }
    }
    //2.设置一个公开的方法停止线程,转换标志位
    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++){
            if(i==900){
                //调用stop方法切换标志位停止线程
                testStop.stop();
                System.out.println("stop");
            }
        }

    }
}

5.4 线程休眠 

1. sleep指定当前线程阻塞的毫秒数

2.sleep存在异常InterruptedException

3.sleep时间达到后线程进入就绪状态

4.sleep可以模拟网络延时,倒计时等

5.每一个对象都有一个锁,sleep不会释放锁

package state;

import java.text.SimpleDateFormat;
import java.util.Date;

//模拟倒计时
public class TestSleep2 {

    public static void main(String[] args) {
        //打印当前系统时间
        Date starTime = new Date(System.currentTimeMillis());//获取当前时间
        while(true){
            try {
                Thread.sleep(1000);
                System.out.println(new SimpleDateFormat("HH:MM:SS").format(starTime));
                starTime = new Date(System.currentTimeMillis());//更新当前时间
            }catch (InterruptedException e){
                e.printStackTrace();
            }
        }
    }
        
       /* try {
            tendown();
        }catch (InterruptedException e){
            e.printStackTrace();
        }
    }*/

    public static void tendown()throws InterruptedException{
        int num = 10;
        while(true){
            Thread.sleep(1000);
            System.out.println(num--);
            if(num<=0){
                break;
            }
        }
    }
}

5.5 线程礼让 

1.礼让线程,让当前正在执行的线程暂停,但不阻塞

2.将线程从运行状态转化为就绪状态

3.让CPU重新调度,但是礼让不一定成功

package state;
//测试礼让线程
public class TestYield {

    public static void main(String[] args) {
        MyYield myYield = new MyYield();
        new Thread(myYield,"a").start();
        new Thread(myYield,"b").start();
        
    }
    
}
class MyYield implements Runnable{
    @Override
    public void run() {
        System.out.println(Thread.currentThread().getName()+"start");
        Thread.yield();
        System.out.println(Thread.currentThread().getName()+"stop");
    }
}

5.6 Join 

1.Join合并线程,待此线程执行完成后,再执行其他线程,其他线程阻塞

2.可以想成插队

package state;

public class TestJoin implements Runnable{
    @Override
    public void run() {
        for(int i=0;i<100;i++){
            System.out.println("线程VIP come"+i);
        }
    }


    public static void main(String[] args) throws InterruptedException {
        TestJoin testJoin = new TestJoin();
        Thread thread = new Thread(testJoin);
        thread.start();//启动线程
        
        for(int i=0;i<1000;i++){
            if(i==200){
                thread.join();//插队
            }
            System.out.println("main"+i);
        }
    }
    
}

 5.7 线程状态观测

package state;

public class TestState {

    public static void main(String[] args) {
        Thread thread = new Thread(()->{
            for(int i=0 ;i<5;i++){
                try {
                    Thread.sleep(1000);
                }catch(InterruptedException e){
                    e.printStackTrace();
                }
            }
            System.out.println(".......");
        });
        
        //观察状态
        Thread.State state = thread.getState();
        System.out.println(state);
        //观察启动后
        thread.start();//启动线程
        state  = thread.getState();
        System.out.println(state);//Run
        
        
        while(state!=Thread.State.TERMINATED){//只要线程不终止 就一直输出状态
            try {
                Thread.sleep(100);
            }catch (InterruptedException e){
                e.printStackTrace();
            }
        }
    }
    
}

六.线程优先级 

1.线程调度按照优先级决定应该调度哪个线程来执行

2.线程的优先级用数字表示,范围从1~10

1)Thread.MIN_PRIORITY = 1;

2)Thread.MAX_PRORITY= 10;

3)Thread.NORM_PRIORITY=5;

3.使用以下方式改变获取优先级

1)getPriority().setPriority(int xxx)

package state;

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);
        Thread t5 = new Thread(myPriority);
        Thread t6 = new Thread(myPriority);
        //先设置优先级 再启动
        t1.start();

        t2.setPriority(1);
        t2.start();

        t3.setPriority(4);
        t3.start();

        t4.setPriority(Thread.MAX_PRIORITY);
        t4.start();

        t5.setPriority(-1);
        t5.start();

        t6.setPriority(11);
        t6.start();
    }


}
class MyPriority implements Runnable{
    @Override
    public void run() {
        System.out.println(Thread.currentThread().getName()+"-->"+Thread.currentThread().getPriority());
    }
}

5.8 守护(daemon)线程 

1.线程分为用户线程和守护线程

2.虚拟机必须确保用户线程执行完毕

3.虚拟机不用等待守护线程执行完毕

4.如,后台记录操作日志,监控内存,垃圾回收等待

package state;
//你死了 上帝也会停止 不会一直执行
public class TestDaemon {
    public static void main(String[] args) {
        God god = new God();
        You you = new You();
        Thread thread1 = new Thread(god);
        thread1.setDaemon(true);//默认是false表示是用户线程 正常的线程都是用户线程
        Thread thread2 = new Thread(you);
        thread1.start();
        thread2.start();

    }
}


//上帝
class God implements Runnable{
    @Override
    public void run() {
        while(true){
            System.out.println("God bless you");
        }
    }
}



//你
class You implements Runnable{
    @Override
    public void run() {
        for(int i=0;i<36500;i++){
            System.out.println("happy");
        }
        System.out.println("========bye========");
    }
}

六.线程同步 

1.定义:是一种等待机制,多个需要同时访问此对象的线程进入这个对象的等待池形成队列,等待前面线程使用完毕,下一个线程再使用

2.形成条件:队列+锁

3.为了保证数据在方法中被访问时的正确性,在访问时加入锁机制synchronized,当一个线程获得对象的排它锁,独占资源,其他线程必须等待,使用后释放锁

package syn;
//不安全的买票
public class UnselfBuyTicket {
    public static void main(String[] args) {
        BuyTicket station = new BuyTicket();
        new Thread(station,"A").start();
        new Thread(station,"B").start();
        new Thread(station,"C").start();
    }
}
class BuyTicket implements Runnable{
    //买票
    private  int ticketNums = 10;
    boolean flag  = true;//外部停止方式
    @Override
    public void run() {
        //买票
        while(flag){
            try {
                buy();
            }catch (InterruptedException e){
                e.printStackTrace();
            }

        }    }
    private void buy()throws InterruptedException{
        //判断是否有票
        if(ticketNums<=0){
            return;
        }
        //模拟延时
        Thread.sleep(100);
        //买票
        System.out.println(Thread.currentThread().getName()+"拿到"+ticketNums--);
    }
}
package syn;
//不安全的取钱
//两个人去银行取钱
public class UnsafeBank {
    public static void main(String[] args) {
        //账户
        Account account = new Account(100,"A");
        Drawing A = new Drawing(account,60,"A");
        Drawing B = new Drawing(account,100,"B");
        A.start();
        B.start();
    }
}

//账号
class Account{
    int money;//余额
    String name;//卡名

    public Account(int money,String name) {
        this.money = money;
        this.name = name;
    }
}

//银行:模拟取款
class Drawing extends Thread{
    Account account;//账号
    //取了多少钱
    int drawingMoney;
    //现在手里有多少钱
    int nowMoney;
    public Drawing(Account account,int drawingMoney,String name){
        this.account=account;
        this.drawingMoney=drawingMoney;
        this.getName();
        this.setName("");
    }
    //取钱
    @Override
    public void run(){
        if(account.money<=0){
            System.out.println(Thread.currentThread().getName()+"余额不足");
            return;
        }
        try {
            Thread.sleep(100);
        } catch (InterruptedException e) {
            throw new RuntimeException(e);
        }
        //卡内余额 = 金额-你取的钱
        account.money=account.money-drawingMoney;
        //手里的钱
        nowMoney=nowMoney+drawingMoney;
        System.out.println(account.name+"余额为"+account.money);
        //Thread.currentThread().getName()=this.getName()
        System.out.println(this.getName()+"手里的钱"+nowMoney);
    }
}
package syn;
import java.util.ArrayList;
import java.util.List;
//线程不安全的集合
public class UnsafeList {
    public static void main(String[] args) {
        List<String> list = new ArrayList<String>();
        for(int i=0;i<10000;i++){
            new Thread(()->{
                list.add(Thread.currentThread().getName());
            }).start();
        }
        try {
            Thread.sleep(200);
        } catch (InterruptedException e) {
            throw new RuntimeException(e);
        }
        System.out.println(list.size());
    }
}

6.1 同步方法 

1.public synchronized void method (int args){}

2.synchronized控制对对象的访问,每个对象对应一把钥匙,每个synchronized方法都必须获得调用该方法的对象的锁才能执行,否则会阻塞,一旦执行,独占该锁,直到该方法返回才释放,后面被阻塞的线程才能获得这个锁,继续执行

3.弊端:方法中需要修改的内容才需要锁,锁的太多,浪费资源

4.同步块:synchronized(obj){}

 1)obj称为同步监视器,可以是任意对象

2)同步方法中无需指定同步监视器,因为同步方法的同步监视器就是this或者是class

5.同步监视器执行过程

1)第一个线程访问,锁定同步监视器,执行其中代码

2)第二个线程访问,发现同步监视器被锁定,无法访问

3)第一个线程访问完毕,解锁同步监视器

4)第二个线程访问,发现同步监视器没有锁,然后锁定并访问

package syn;
//不安全的买票
public class UnselfBuyTicket {
    public static void main(String[] args) {
        BuyTicket station = new BuyTicket();
        new Thread(station,"A").start();
        new Thread(station,"B").start();
        new Thread(station,"C").start();
    }
}
class BuyTicket implements Runnable{
    //买票
    private  int ticketNums = 10;
    boolean flag  = true;//外部停止方式
    @Override
    public void run() {
       
        //买票
        while(flag){
            try {
                buy();
            }catch (InterruptedException e){
                e.printStackTrace();
            }

        }    }
    //synchronized锁的是this
    private synchronized void buy()throws InterruptedException{
        //判断是否有票
        if(ticketNums<=0){
            return;
        }
        //模拟延时
        Thread.sleep(100);
        //买票
        System.out.println(Thread.currentThread().getName()+"拿到"+ticketNums--);
    }
}
package syn;
//不安全的取钱
//两个人去银行取钱
public class UnsafeBank {
    public static void main(String[] args) {
        //账户
        Account account = new Account(100,"A");
        Drawing A = new Drawing(account,60,"A");
        Drawing B = new Drawing(account,100,"B");
        A.start();
        B.start();
    }
}

//账号
class Account{
    int money;//余额
    String name;//卡名

    public Account(int money,String name) {
        this.money = money;
        this.name = name;
    }
}

//银行:模拟取款
class Drawing extends Thread {
    Account account;//账号
    //取了多少钱
    int drawingMoney;
    //现在手里有多少钱
    int nowMoney;

    public Drawing(Account account, int drawingMoney, String name) {
        this.account = account;
        this.drawingMoney = drawingMoney;
        this.getName();
        this.setName("");
    }

    //取钱
    @Override
    public void run() {
        synchronized (account) {
            if (account.money <= 0) {
                System.out.println(Thread.currentThread().getName() + "余额不足");
                return;
            }
            try {
                Thread.sleep(100);
            } catch (InterruptedException e) {
                throw new RuntimeException(e);
            }
            //卡内余额 = 金额-你取的钱
            account.money = account.money - drawingMoney;
            //手里的钱
            nowMoney = nowMoney + drawingMoney;
            System.out.println(account.name + "余额为" + account.money);
            //Thread.currentThread().getName()=this.getName()
            System.out.println(this.getName() + "手里的钱" + nowMoney);
        }
    }
}
package syn;
import java.util.ArrayList;
import java.util.List;
//线程不安全的集合
public class UnsafeList {
    public static void main(String[] args) {
        List<String> list = new ArrayList<String>();
        for(int i=0;i<10000;i++){
            new Thread(()->{
                synchronized (list) {
                    list.add(Thread.currentThread().getName());
                }
            }).start();
        }
        try {
            Thread.sleep(200);
        } catch (InterruptedException e) {
            throw new RuntimeException(e);
        }
        System.out.println(list.size());
    }
}
package syn;
import java.util.concurrent.CopyOnWriteArrayList;
//测试JUC安全
public class TestJUC {
    public static void main(String[] args) {
        CopyOnWriteArrayList<String> list = new CopyOnWriteArrayList();
        for(int i=0;i<10000;i++){
            new Thread(()->{
                list.add(Thread.currentThread().getName());
            }).start();
        }
        try {
            Thread.sleep(200);
        } catch (InterruptedException e) {
            throw new RuntimeException(e);
        }
        System.out.println(list.size());
    }
}

6.2 死锁

某一个同步块同时拥有两个以上的对象锁,可能会发生死锁

 

//多个线程互相拥抱着对方需要的资源,然后形成僵持
public class DeadLock {
    public static void main(String[] args) {
        Makeup A = new Makeup(0,"A");
        Makeup B = new Makeup(0,"b");
        A.start();
        B.start();
    }
}
//口红
class Lipstick {

}

//镜子
class Mirror{

}

class Makeup extends Thread{
    //需要的资源只有一份,用static来保证只有一份
   static Lipstick lipstick=  new Lipstick();
    static Mirror mirror=  new Mirror();
    int choice;//选择
    String name;//使用化妆品的人
    Makeup(int choice , String name){
        this.choice= choice;
        this.name = name;
    }
    @Override
    public void run() {
      //化妆
    }
    //化妆 互相持有对方的锁 需要拿到对方的资源
    private void makeup()throws InterruptedException{
        if(choice==0){
            synchronized (lipstick){//获得口红的锁
                System.out.println(this.getName()+"获得口红的锁");
                Thread.sleep(2000);
                synchronized (mirror){//2秒后想获得镜子
                    System.out.println(this.getName()+"获得镜子的锁");
                }
            }
        }
    }
}

6.3 Lock(锁) 

 1.锁提供了对共享资源的独占访问,每次只能有一个线程对Lock对象加锁,线程开始访问共享资源之前应该获得Lock对象

2.ReentrantLock类实现了Lock,它拥有与synchornized相同的并发性和内存语义,在线程安全的控制中,比较常用的是ReentranLock,可以显示加锁、释放锁

package gaoji;
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(); 
        new Thread(testlock2).start();
    }
}
class Testlock2 implements Runnable{
    int ticketNums= 10;
    //定义lock锁
    private final ReentrantLock lock = new ReentrantLock();
    
    @Override
    public void run() {
        while(true){//加锁
            try {

                lock.lock();
                if (ticketNums > 0) {
                    try {
                        Thread.sleep(1000);
                    } catch (InterruptedException e) {
                        throw new RuntimeException(e);
                    }
                    System.out.println(ticketNums--);
                } else {
                    break;
                }
            }finally {
                //解锁
                lock.unlock();
            }
        }
    }
}

 七.线程协作

7.1 线程通信

1.应用场景:生产者和消费者问题

1)假设仓库中只能存放一件产品,生产者将生产出来的产品放入仓库,消费者将仓库中产品取走消费

2)如果仓库中没有产品,则生产者将产品放入仓库中,否则停止生产并等待,直到仓库中的产品被消费者取走为止

3)如果仓库中放有产品,则消费者可以将产品取走消费,否则停止消费并等待,直到仓库中再次放入产品为止

2.在生产者消费问题,仅有synchornized是不够的

3.方法

1)wait():表示线程一直等待,直到其他线程通知,与sleep不同,会释放锁

2)wait(long timeout):指定等待的毫秒数

3)notify():唤醒一个处于等待状态的线程

4)notifyAll():唤醒同一个对象上所有调用wait()方法的线程,优先级别高的线程优先调度

tips:均是Object类的方法,都只能在同步方法或者同步代码块中使用,否则会抛出异常IIIegalMonitorStateException

4.解决方式1

并发协作模型"生产者/消费者模式"----->管程法

1)生产者:负责生产数据的模块(可能是方法、对象、线程、进程)

 2)消费者:负责处理数据的模块(可能是方法、对象、线程、进程)

3)缓冲区:消费者不能直接使用生产者的数据,他们之间有个"缓冲区"

生产者将生产好的数据放入缓冲区,消费者从缓冲区拿出数据

package gaoji;

//测试生产/消费者利用缓冲区解决
//生产者、消费者、产品、缓冲区
public class TestPC {
    public static void main(String[] args) {
        SynContainer synContainer = new SynContainer();
        new Productor(synContainer).start();
        new Cousumer(synContainer).start();
    }
}
       

//生产者
class Productor extends Thread{
    SynContainer container;
    public Productor(SynContainer container){
        this.container=container;
    }
    //生产

    @Override
    public void run() {
        for (int i=0;i<100;i++){
            System.out.println("生产力"+i+"只鸡");
            container.push(new Chicken(i));
        }
    }
}

//消费者
class Cousumer extends Thread {
    SynContainer container;
    public Cousumer(SynContainer container){
        this.container=container;
    }
    //消费

    @Override
    public void run() {
        for(int i=0;i<100;i++){
            System.out.println("消费了"+container.pop().id+"只鸡");
        }
    }
}
//产品
class Chicken{
    public Chicken(int id) {
        this.id = id;
    }

    int id;//产品编号
    
}
//缓冲区
class SynContainer{
    //容器大小
    Chicken[] chickens = new Chicken[10];
    //容器计数器
    int count = 0;
    //生产者放入产品
    public synchronized void push(Chicken chicken){
        //如果容器满了,就需要等待消费者消费
        if(count== chickens.length){
            //通知消费者消费,生产等待
        }
        
        //如果容器没有满,我们就需要丢入产品
        chickens[count] = chicken;
        count++;
        //可以通知消费者消费了
    }
    
    //消费者消费产品
    public synchronized Chicken pop(){
        if(count==0){
            //等待生产者生产,消费者等待
        }
        //如果可以消费
        count--;
        Chicken chicken= chickens[count];
        //消费完了,通知生产者生产
        return chicken;
    }
    
}

解决方式2 

并发协作模型"生产者/消费者模式"----->信号灯法

package gaoji;

import com.sun.xml.internal.ws.runtime.config.TubelineFeatureReader;

public class TestPC2 {
    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("D");
           }else{
               this.tv.play("E");
           }

        }
    }
}


//消费者--->观众
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{
    //演员表演 观众等待
    //观众观看 演员等待
    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;
    }

}

  八.使用线程池

思路:提前创好多个线程,放入线程池中,使用时直接获取,使用完放回池中,可以避免频繁创建销毁、实现重复利用

好处:

提高响应速度(减少了创建新线程的时间)

降低资源消耗

便于线程管理

1.ExecutorService:真正的线程池接口,常见子类ThreadPoolExcutor

1):void execute(Runnable command):执行任务/命令,没有返回值,一般用来执行Runnable

2):<T>Future<T>submit(Callable<T>task):执行任务,有返回值,一般又来执行Callable

3):void shutdown():关闭连接池

2.Executors:工具类

package gaoji;

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

import static java.lang.Thread.currentThread;

public class TestPool {
    public static void main(String[] args) {
        //1.创建服务 创建线程池
        //newFixedThreadPool 参数为:线程池大小
        ExecutorService service = Executors.newFixedThreadPool(10);
        service.execute(new MyThread());
        service.execute(new MyThread());
        service.execute(new MyThread()); 
        service.execute(new MyThread());
        //2.关闭链接
        service.shutdown();
        
    }
}
class MyThread implements Runnable{
    @Override
    public void run() {
        for(int i=0;i<100;i++){
            System.out.println(Thread.currentThread());
        }
    }
}

评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值