2021-03-21：java第21天：进程和线程，线程安全问题，锁

于 2021-03-22 01:32:03 发布
阅读量117 收藏
点赞数
文章标签： 多线程 java 并发编程
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_41179957/article/details/115057614
版权

1.多线程随机打印结果的原理

线程的内存图：

2.Thread类的常用方法

package Part2.Day_21;

public class Mythread extends Thread{
    //重写thread类中的run方法

    @Override
    public void run() {
        //获取线程名称
        //String name = getName();
        //System.out.println(name);

        //Thread t = Thread.currentThread();
        //System.out.println(t); //Thread[Thread-1,5,main]
        //String name = t.getName();
        //System.out.println(name);

        //链式编程
        System.out.println(Thread.currentThread().getName());

    }
}


package Part2.Day_21;
/*
    线程的名称：
        主线程 main
        新线程 thread-0 thread-1 thread-2
 */
public class demo01getthreadname {
    public static void main(String[] args) { //main
        Mythread mt = new Mythread();
        //调用start方法，开启新线程，执行run方法
        mt.start(); //thread 0

        new Mythread().start(); //thread 1
        new Mythread().start(); //thread 2

        System.out.println(Thread.currentThread().getName()); //主线程的名称
    }
}

 

package Part2.Day_21.demo02;
/*
    设置线程的名称：
       1.使用Thread类中的方法setName(名字)
 */
public class MyThread extends Thread{
    public MyThread(){}

    public MyThread(String name) {
        super(name);
    }

    @Override
    public void run() {
        System.out.println(Thread.currentThread().getName());
    }
}


package Part2.Day_21.demo02;

import Part2.Day_21.demo01.Mythread;

public class demo01setthreadname {
    public static void main(String[] args) {
        //开启多线程
        Mythread mt = new Mythread();
        mt.setName("小强");
        mt.start();

        //开启多线程
        new MyThread("旺财").start();

        /*
        运行结果：
        小强
        旺财
         */
    }
}


package Part2.Day_21.demo02;

public class demo01sleep {
    public static void main(String[] args) {
        for (int i = 0; i <= 60; i++) {
            System.out.println(i);

            //使用thread类的sleep方法让程序睡眠一秒钟
            try {
                Thread.sleep(1000);//毫秒值
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }
}


package Part2.Day_21.demo03;

public class RunnableImpl implements Runnable{
    @Override
    public void run() {
        for (int i = 0; i < 20; i++) {
            System.out.println(Thread.currentThread().getName()+"-->"+i);
        }
    }
}
package Part2.Day_21.demo03;

public class RunnableImpl2 implements Runnable{
    @Override
    public void run() {
        for (int i = 0; i < 20; i++) {
            System.out.println(Thread.currentThread().getName()+"-->"+i);
        }
    }
}

package Part2.Day_21.demo03;
/*
创建多线程程序第二种方式：实现Runnable接口

 */
public class demo01Runnable {
    public static void main(String[] args) {
        RunnableImpl run = new RunnableImpl();

        //Thread t = new Thread(run);
        Thread t = new Thread(new RunnableImpl2());
        t.start();
        for (int i = 0; i < 20; i++) {
            System.out.println(Thread.currentThread().getName()+"-->"+i);
        }
        /*
        Thread-0-->0
        Thread-0-->1
        main-->0
        Thread-0-->2
        main-->1
        Thread-0-->3
        main-->2
        Thread-0-->4
        Thread-0-->5
        main-->3
        Thread-0-->6
        main-->4
        Thread-0-->7
        Thread-0-->8
        Thread-0-->9
        Thread-0-->10
        Thread-0-->11
        Thread-0-->12
        Thread-0-->13
        Thread-0-->14
        Thread-0-->15
        main-->5
        Thread-0-->16
        main-->6
        Thread-0-->17
        main-->7
        Thread-0-->18
        Thread-0-->19
        main-->8
        main-->9
        main-->10
        main-->11
        main-->12
        main-->13
        main-->14
        main-->15
        main-->16
        main-->17
        main-->18
        main-->19

        Process finished with exit code 0

         */
    }
}

 

实现Runnable接口的好处：

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

          一个类只能继承一个类，类继承了Thread类就不能继承其他类

          实现了Runnable接口，还可以继承其他的类，实现其他的接口

2.增强了程序的扩展性，降低了程序的耦合性（解耦）

          实现了Runnable接口的方式，把设置线程任务和开启新线程进行了分离（解耦）

          实现类中，重写了run方法：用来设置线程任务

          创建Thread类对象，调用start方法，用来开启新的线程

 

3.并发与并行

4.匿名内部类的方式实现线程的创建

package Part2.Day_21.demo04;

public class demo01InnerClassThread {
    public static void main(String[] args) {
        new Thread(){
            @Override
            public void run() {
                for (int i = 0; i < 20; i++) {
                    System.out.println(Thread.currentThread().getName()+"-->"+"黑马");
                }
            }
        }.start();

        //线程的接口Runnable
        //RunnableImpl r = new RunnableImpl(); //多态
        Runnable r = new Runnable(){
            @Override
            public void run() {
                System.out.println(Thread.currentThread().getName()+"-->"+"程序员");
            }
        };
        new Thread(r).start();

        //简化接口的方式:
        new Thread(new Runnable(){
            @Override
            public void run() {
                System.out.println(Thread.currentThread().getName()+"-->"+"程序员1");
            }
        }).start();
    }
}

5.进程与线程

6.线程的调度：

分时调度

抢占式调度（JAVA是抢占式调度）

线程的优先级是可以设置的

优先级越高，抢夺CPU的时间更长

7. 主线程

执行main方法的线程

单线程程序：JAVA程序中只有一个线程。执行从main方法开始，从上到下依次进行

8.创建多线程程序的第一种方法 Thread类的子类

9.线程安全问题

10.解决线程安全问题：

第一种方式：

package Part2.Day_21.demo05;
/*
解决线程安全问题
卖出了不存在和重复的票

1.使用同步代码块
格式：
    synchronized(锁对象){
        可能会出现线程安全问题的代码(访问了共享数据的代码)
    }
 */
public class RunnableImpl implements Runnable{
    private int ticket = 100;

    //创建一个锁对象
    Object obj = new Object();


    @Override
    public void run() {
        while (true){
            synchronized (obj){
                if (ticket>0){
                    //提高安全问题出现的概率，让程序睡眠
                    try {
                        Thread.sleep(10);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                    System.out.println(Thread.currentThread().getName()+"->正在卖第"+ticket+"张票");
                    ticket--;
                }
            }

            //判断票是否存在

        }

    }
}



package Part2.Day_21.demo05;
/*
    模拟卖票案例
    创建3个线程，同时开启，对共享的票进行出售
 */
public class demo01Ticket {
    public static void main(String[] args) {
        RunnableImpl run = new RunnableImpl();
        //创建Thread类对象，构造方法中传递Runnable接口的实现类对象
        Thread t0 = new Thread(run);
        Thread t1 = new Thread(run);
        Thread t2 = new Thread(run);
        //一个实现类，3个线程，共享票源,出现同时卖同一张票的情况，线程安全问题
        t0.start();
        t1.start();
        t2.start();
    }
}

 

第二种方式：

 

package Part2.Day_21.demo06;
/*
解决线程安全问题
卖出了不存在和重复的票

1.使用同步方法
步骤：
    1.把访问了共享数据的代码抽取出来，放到一个方法中
    2.在方法上添加sychronized修饰符
格式：
    修饰符 synchronized 返回值类型 方法名(参数列表){
        可能会出现线程安全问题的代码
    }
 */
public class RunnableImpl implements Runnable{
    private int ticket = 100;

    //创建一个锁对象
    Object obj = new Object();


    @Override
    public void run() {
        while (ticket>0){
            payTicket();
            //判断票是否存在
        }
    }
    public synchronized void payTicket(){
        if (ticket>0){
            //提高安全问题出现的概率，让程序睡眠
            try {
                Thread.sleep(10);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println(Thread.currentThread().getName()+"->正在卖第"+ticket+"张票");
            ticket--;
        }
        
    }
}


package Part2.Day_21.demo06;

/*
    模拟卖票案例
    创建3个线程，同时开启，对共享的票进行出售
 */
public class demo01Ticket {
    public static void main(String[] args) {
        RunnableImpl run = new RunnableImpl();
        //创建Thread类对象，构造方法中传递Runnable接口的实现类对象
        Thread t0 = new Thread(run);
        Thread t1 = new Thread(run);
        Thread t2 = new Thread(run);
        //一个实现类，3个线程，共享票源,出现同时卖同一张票的情况，线程安全问题
        t0.start();
        t1.start();
        t2.start();
    }
}

也是把方法内部的代码锁住

只让一个线程进行

同步方法的锁对象是new RunnableImpl() 也就是this

 

静态同步方法：

package Part2.Day_21.demo06;
/*
解决线程安全问题
卖出了不存在和重复的票

1.使用同步方法
步骤：
    1.把访问了共享数据的代码抽取出来，放到一个方法中
    2.在方法上添加sychronized修饰符
格式：
    修饰符 synchronized 返回值类型 方法名(参数列表){
        可能会出现线程安全问题的代码
    }
 */
public class RunnableImpl implements Runnable{
    private static int ticket = 100;

    //创建一个锁对象
    Object obj = new Object();


    @Override
    public void run() {
        while (ticket>0){
            payTicketStatic();
            //判断票是否存在
        }
    }
    public static synchronized void payTicketStatic(){
        if (ticket>0){
            //提高安全问题出现的概率，让程序睡眠
            try {
                Thread.sleep(10);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println(Thread.currentThread().getName()+"->正在卖第"+ticket+"张票");
            ticket--;
        }

    }
}

锁对象不是this，因为this是创建对象之后产生的，而静态方法优先于对象

静态方法的锁对象是本类的class属性-->class文件对象（反射）RunnableImpl.class（了解即可）

第三种方式：LOCK锁

package Part2.Day_21.demo07;

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

/*
解决线程安全问题
卖出了不存在和重复的票

1.使用LOCK锁
java.util.concurrent.Locks.Lock接口
Lock 接口中的方法：
void Lock()获取锁
void unlock()释放锁
java.util.concurrent.Locks.ReentrantLock implements Lock接口


 */
public class RunnableImpl implements Runnable{
    private int ticket = 100;

    //创建一个锁对象
    Object obj = new Object();
    Lock l =new ReentrantLock();

    @Override
    public void run() {
        while (ticket>0){
                l.lock();
                if (ticket>0){
                    //提高安全问题出现的概率，让程序睡眠
                    try {
                        Thread.sleep(10);
                        System.out.println(Thread.currentThread().getName()+"->正在卖第"+ticket+"张票");
                        ticket--;
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    } finally {
                        l.unlock();
                    }
                    
                }
                

            //判断票是否存在

        }

    }
}

 

try catch 把锁放在finally块里释放掉

 

qq_41179957
关注
评论 3
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值