java---进程和线程

于 2022-06-29 17:27:22 发布
阅读量170 收藏
点赞数
分类专栏： java 文章标签： 大数据 java intellij idea
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.youkuaiyun.com/z2021_000000/article/details/125525917
版权

实现多线程

多线程的实现方式：
方式1:继承Thread
package 进程和线程.实现多线程.多线程的实现方式;
/*
    方式1:继承Thread
        定义一个类MyThread继承Thread类
        在MyThread类中重写run（）方法
        创建MyThread对象
        启动线程

 */

public class myThread extends Thread {
    @Override
    public void run() {
        for (int i = 0; i <100; i++) {
            System.out.println(i);
        }
    }
}

package 进程和线程.实现多线程.多线程的实现方式;

public class myThreadDemo {
    public static void main(String[] args) {

        myThread my1=new myThread();
        myThread my2=new myThread();

        //void start​() 导致此线程开始执行; Java虚拟机调用此线程的run方法。
        my1.start();
        my2.start();


    }
}

方式2:实现Runnable接口
package 进程和线程.实现多线程.多线程的实现方式;

public class MyRunnable implements Runnable {
    @Override
    public void run() {
        for (int i = 0; i <100; i++) {
            System.out.println(Thread.currentThread().getName()+";"+i);
        }
    }
}
package 进程和线程.实现多线程.多线程的实现方式;
/*
    多线程的实现方式
        方式2:实现Runnable接口
            定义一个类MyRunnable实现Runnable接口在MyRunnable类中重写run0)方法
            创建MyRunnable类的对象
            创建Thread类的对象，把MyRunnable对象作为构造方法的参数
            启动线程

    多线程的实现方案有两种
        继承Thread类
        实现Runnable接口

    相比继承Thread类，实现Runnable接口的好处
    避免了Java单继承的局限性
    适合多个相同程序的代码去处理同一个资源的情况，把线程和程序的代码、数据有效分离，较好的体现了面向对象的设计思想
 */

public class MyRunnableDemo {
    public static void main(String[] args) {
        //创建MyRunnable类的对象
        MyRunnable my=new MyRunnable();

        // 创建Thread类的对象，把MyRunnable对象作为构造方法的参数
        //Thread (Runnable target)
        Thread t1=new Thread(my,"高铁");
        Thread t2=new Thread(my,"飞机");

        //启动线程
        t1.start();
        t2.start();

    }
}
设置和获取线程名称
package 进程和线程.实现多线程.设置和获取线程名称;

public class MyThread   extends Thread {

    public MyThread(){}

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

    @Override
    public void run() {
        for(int i = 0; i <100; i++){
            System.out.println(getName()+":"+i);
        }
    }
}

package 进程和线程.实现多线程.设置和获取线程名称;
/*
        设置和获取线程名称
            Thread类中设置或获取线程名称的方法
                void setName(String name):将此线程的名称更改为等于参数 name
                String getName() :返回此线程名称

        如何获取main（）方法所在线程名称？
            public static Thread currentThread():返回对当前正在执行的线程对象的引用。
 */

public class MyThreadDemo {
    public static void main(String[] args) {

//        MyThread my1=new MyThread();
//        MyThread my2=new MyThread();

        //void setName​(String name) 将此线程的名称更改为等于参数 name 。
//        my1.setName("高铁");
//        my2.setName("飞机");

        //Thread(String name)
//        MyThread my1=new MyThread("高铁");
//        MyThread my2=new MyThread("飞机");
//
//
//        my1.start();
//        my2.start();

        //static Thread currentThread​() 返回对当前正在执行的线程对象的引用。
        System.out.println(Thread.currentThread().getName());


    }
}

线程调度
package 进程和线程.实现多线程.线程调度;

public class ThreadPriority  extends Thread {
    @Override
    public void run() {
        for (int i = 0; i <100; i++) {
            System.out.println(getName() + ": " + i);
        }
    }
}

package 进程和线程.实现多线程.线程调度;

public class ThreadPriorityDemo {
    public static void main(String[] args) {
        ThreadPriority tp1=new ThreadPriority();
        ThreadPriority tp2=new ThreadPriority();
        ThreadPriority tp3=new ThreadPriority();

        tp1.setName("高铁");
        tp2.setName("飞机");
        tp3.setName("汽车");

        //int getPriority​() 返回此线程的优先级
        System.out.println(tp1.getPriority());//5
        System.out.println(tp2.getPriority());//5
        System.out.println(tp3.getPriority());//5

        //void setPriority​(int newPriority) 更改此线程的优先级。
//        tp1.setPriority(10000);//IllegalArgumentException
        System.out.println(Thread.MAX_PRIORITY);//10
        System.out.println(Thread.MIN_PRIORITY);//1
        System.out.println(Thread.NORM_PRIORITY);//5

        tp1.setPriority(5);
        tp2.setPriority(10);
        tp3.setPriority(1);

        tp1.start();
        tp2.start();
        tp3.start();


    }
}

线程控制
package 进程和线程.实现多线程.线程控制;

public class ThreadSleep extends Thread {
    @Override
    public void run() {
        for (int i = 0; i <100; i++) {
            System.out.println(getName() + ": " + i);
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }
}

package 进程和线程.实现多线程.线程控制;
//  static void sleep​(long millis)
//  使当前正在执行的线程停留（暂停执行）指定的毫秒数

public class ThreadSleepDemo {
    public static void main(String[] args) {
        ThreadSleep ts1=new ThreadSleep();
        ThreadSleep ts2=new ThreadSleep();
        ThreadSleep ts3=new ThreadSleep();

        ts1.setName("曹操");
        ts2.setName("刘备");
        ts3.setName("孙权");

        ts1.start();
        ts2.start();
        ts3.start();
    }
}

package 进程和线程.实现多线程.线程控制;

public class ThreadJoin extends Thread {
    @Override
    public void run() {
        for (int i = 0; i <100; i++) {
            System.out.println(getName() + ": " + i);
        }
    }
}

package 进程和线程.实现多线程.线程控制;
//void join​() 等待这个线程死亡。

public class ThreadJoinDemo {
    public static void main(String[] args) {
        ThreadJoin tj1=new ThreadJoin();
        ThreadJoin tj2=new ThreadJoin();
        ThreadJoin tj3=new ThreadJoin();

        tj1.setName("康熙");
        tj2.setName("四阿哥");
        tj3.setName("八阿哥");

        tj1.start();
        try {
            tj1.join();//只有当康熙走后，他俩才能争夺皇位
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        tj2.start();
        tj3.start();

    }
}

package 进程和线程.实现多线程.线程控制;

public class ThreadDaemon extends Thread {
    @Override
    public void run() {
        for (int i = 0; i <100; i++) {
            System.out.println(getName() + ": " + i);
        }
    }
}

package 进程和线程.实现多线程.线程控制;

/*void setDaemon(boolean on):将此线程标记为守护线程，
 当运行的线程都是守护线程时，Java虚拟机将退出*/
public class ThreadDaemonDemo {
    public static void main(String[] args) {
        ThreadDaemon td1=new ThreadDaemon();
        ThreadDaemon td2 = new ThreadDaemon();
        td1.setName("关羽");
        td2.setName("张飞");
        //设置主线程为刘备
        Thread.currentThread().setName("刘备");
        //设置守护线程
        td1.setDaemon(true);
        td2.setDaemon(true);
        td1.start();
        td2.start();
        for (int i = 0; i < 10; i++) {
            System.out.println(Thread.currentThread().getName() + ":" + i);
        }
    }


}
线程同步
线程安全的类
package 进程和线程.线程同步;

public class 线程安全的类 {
/*
    StringBuffer
        线程安全，可变的字符序列
        从版本JDK5开始，被StringBuilder替代。通常应该使用StrinqBuilder类，因为它支持所有相同的操作，但它更快，因为它不执行同步

    Vector
        ●从Java2平台v1.2开始，该类改进了List接口，使其成为JavaCollectionsFramework的成员。
        与新的集合实现不同，Vector被同步。如果不需要线程安全的实现，建议使用ArrayList代替Vector

    Hashtable
        该类实现了一个哈希表，它将键映射到值。任何非null对象都可以用作键或者值
        从Java2平台v1.2开始，该类进行了改进，实现了Map接口，使其成为JavaCollectionsFramework的成员。与新的集合实现不同，Hashtable被同步。如果不需要线程安全的实现，建议使用HashMap代替Hashtable
     */
}

同步代码块
package 进程和线程.线程同步.同步代码块;
/*
卖票案例数据安全问题的解决
    为什么出现问题?(这也是我们判断多线程程序是否会有数据安全问题的标准)
    1.是否是多线程环境
    2.是否有共享数据
    3.是否有多条语句操作共享数据

如何解决多线程安全问题呢?
    基本思想:让程序没有安全问题的环境

怎么实现呢?
    把多条语句操作共享数据的代码给锁起来，让任意时刻只能有一个线程执行即可
     Java提供了同步代码块的方式来解决
 */
/*
同步代码块实现
    格式:
    synchronized(任意对象){
    多条语句操作共享数据的代码

    synchronized(任意对象):就相当于给代码加锁了，任意对象就可以看成是一把锁

同步的好处和弊端
    好处:解决了多线程的数据安全问题
    弊端:当线程很多时，因为每个线程都会去判断同步上的锁，这是很耗费资源的，无形中会降低程序的运行效率
 */
public class SellTicket implements Runnable {

        private int tickets=100;
        private Object obj=new Object();

        @Override
        public void run() {
            //tickets = 100;
            //t1,t2,t3
            //假设t1抢到了cpu的执行权
            //假设t2抢到了cpu的执行权
            while (true) {
                synchronized (obj) {
                    //t1进来后就会把这段代码给锁起来
                    if (tickets>0) {
                        try {
                            Thread.sleep(100);
                            //t1休息100毫秒
                        } catch (InterruptedException e) {
                            e.printStackTrace();
                        }
                        //窗口1正在出售第100张票
                        System.out.println(Thread.currentThread().getName()+"正在出售第"+tickets+"张票");
                        tickets--;//tickets=99;
                    }
                }
                //t1出来了，这段代码的锁就被释放
            }
        }

    }


package 进程和线程.线程同步.同步代码块;


public class SellTicketDemo {
    public static void main(String[] args) {
        SellTicket st=new SellTicket();

        Thread t1=new Thread(st,"窗口1");
        Thread t2=new Thread(st,"窗口2");
        Thread t3=new Thread(st,"窗口3");

        t1.start();
        t2.start();
        t3.start();
    }
}

同步方法
package 进程和线程.线程同步.同步方法;
/*
    同步方法:
        就是把synchronized关键字加到方法上
    格式:
        修饰符 synchronized 返回值类型 方法名(方法参数){}
    同步方法的锁对象是什么呢?
        this

    同步静态方法:
        就是把synchronized关键字加到静态方法上格式:
        修饰符 static synchronized 返回值类型 方法名(方法参数){}
    同步静态方法的锁对象是什么呢?
        类名.class
 */

public class SellTicket implements Runnable {
    private static int tickets = 100;
    private Object obj = new Object();
    private int x = 0;

    @Override
    public void run() {
        while (true) {
            if (x % 2 == 0) {
                synchronized (/*obj*//*this*/SellTicket.class) {
                    if (tickets > 0) {
                        try {
                            Thread.sleep(100);
                        } catch (InterruptedException e) {
                            e.printStackTrace();
                        }
                        System.out.println(Thread.currentThread().getName() + "正在出售第" + tickets + "张票");
                        tickets--;
                    }
                }
                sellTicket();
            }
            x++;
        }
    }

    /*private synchronized void sellTicket() {

        if (tickets > 0) {
            try {
                Thread.sleep(100);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println(Thread.currentThread().getName() + "正在出售第" + tickets + "张票");
            tickets--;
            }
        }
    */
    private static synchronized void sellTicket() {

        if (tickets > 0) {
            try {
                Thread.sleep(100);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println(Thread.currentThread().getName() + "正在出售第" + tickets + "张票");
            tickets--;
        }
    }

}

package 进程和线程.线程同步.同步方法;

public class SellTicketDemo {
    public static void main(String[] args) {
        SellTicket st=new SellTicket();

        Thread t1=new Thread(st,"窗口1");
        Thread t2=new Thread(st,"窗口2");
        Thread t3=new Thread(st,"窗口3");

        t1.start();
        t2.start();
        t3.start();
    }
}

Lock锁
package 进程和线程.线程同步.Lock锁;
/*
   Lock锁
    虽然我们可以理解同步代码块和同步方法的锁对象问题，但是我们并没有直接看到在哪里加上了锁，在哪里释放了锁，为了更清晰的表达如何加锁和释放锁，JDK5以后提供了一个新的锁对象Lock

    Lock实现提供比使用synchronized方法和语句可以获得更广泛的锁定操作 Lock中提供了获得锁和释放锁的方法
        void lock():获得锁
        void unlock():释放锁

    Lock是接口不能直接实例化，这里采用它的实现类ReentrantLock来实例化
    ReentrantLock的构造方法
        ReentrantLock:创建一个ReentrantLock的实例
 */

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

public class SellTicket implements Runnable {
    private int tickets=100;
    private Lock lock=new ReentrantLock();

    @Override
    public void run() {
        while(true) {
            lock.lock();
            try {
                if(tickets>0) {
                    try {
                        Thread.sleep(100);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                    System.out.println(Thread.currentThread().getName() + "正在出售第"+tickets+"张票");
                    tickets--;

                }
            }finally {
                lock.unlock();
            }
//Inspection '在使用阻塞等待获取锁的方式中，必须在try代码块之外，并且在加锁方法与try代码块之间没有任何可能抛出异常的方法调用，避免加锁成功后，在finally中无法解锁。
//说明一：如果在lock方法与try代码块之间的方法调用抛出异常，那么无法解锁，造成其它线程无法成功获取锁。
//说明二：如果lock方法在try代码块之内，可能由于其它方法抛出异常，导致在finally代码块中，unlock对未加锁的对象解锁，它会调用AQS的tryRelease方法（取决于具体实现类），抛出IllegalMonitorStateException异常。
//说明三：在Lock对象的lock方法实现中可能抛出unchecked异常，产生的后果与说明二相同。
        }
    }
}

package 进程和线程.线程同步.Lock锁;

public class SellTicketDemo {
    public static void main(String[] args) {
        SellTicket st=new SellTicket();

        Thread t1=new Thread(st,"窗口1");
        Thread t2=new Thread(st,"窗口2");
        Thread t3=new Thread(st,"窗口3");

        t1.start();
        t2.start();
        t3.start();
    }
}

生产者消费者
package 进程和线程.生产者消费者;
/*
    为了体现生产和消费过程中的等待和唤醒，Java就提供了几个方法供我们使用，这几个方法在Object类中 Object类的等待和唤醒方法:
    方法名 说明
void wait() 导致当前线程等待，直到另一个线程调用该对象的notify()方法或notifyAll()方法
void notify() 唤醒正在等待对象监视器的单个线程
void notifyAll() 唤醒正在等待对象监视器的所有线程
 */
/*
生产者消费者案例中包含的类:
    奶箱类(Box):定义一个成员变量，表示第x瓶奶，
    提供存储牛奶和获取牛奶的操作生产者类(Producer):实现Runnable接口，重写run()方法，
    调用存储牛奶的操作消费者类(Customer):实现Runnable接口，重写run()方法，
    调用获取牛奶的操作测试类(BoxDemo):里面有main方法，main方法中的代码步骤如下

    1.创建奶箱对象，这是共享数据区域
    2.创建生产者对象，把奶箱对象作为构造方法参数传递，因为在这个类中要调用存储牛奶的操作
    3.创建消费者对象，把奶箱对象作为构造方法参数传递，因为在这个类中要调用获取牛奶的操作4
    4.创建2个线程对象，分别把生产者对象和消费者对象作为构造方法参数传递
    5.启动线程


 */

import 集合进阶.Map双列.Map集合的概述和使用;

public class Box {
    //定义一个成员变量，表示第x瓶奶
    private int milk;
    //定义一个成员变量，表示奶箱的状态
    private boolean state=false;

    //提供存储牛奶和获取牛奶的操作
    public synchronized void put(int milk) {
        //如果又牛奶，等待消费
        if (state){
            try {
                wait();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }

        }
        //如果没有牛奶，等待生产
        this.milk=milk;
        System.out.println("送奶工将第"+this.milk+"瓶牛奶放入奶箱");

        //生产完毕，修改奶箱的状态
        state=true;

        //唤醒其他等待的线程
        notifyAll();

}
    public synchronized void get(){
        //如果没有牛奶，等待生产
        if(!state) {
            try {
                wait();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
        //如果有牛奶，就消费牛奶
        System.out.println("用户拿到第"+this.milk+"瓶牛奶");

        //消费完毕，修改奶箱状态
        state=false;

        //唤醒其他等待的线程
        notifyAll();
    }
}

package 进程和线程.生产者消费者;

public class Producer implements Runnable {
    private Box b;

    public Producer(Box b) {
        this.b = b;
    }

    @Override
    public void run() {
        for(int i = 1; i <=5;i++) {
            b.put(i);
        }
    }
}

package 进程和线程.生产者消费者;

public class Customer implements Runnable {
    private Box b;

    public Customer(Box b) {
        this.b = b;
    }

    @Override
    public void run() {
        while (true) {
            b.get();
        }
    }
}

package 进程和线程.生产者消费者;
/*
    1.创建奶箱对象，这是共享数据区域
    2.创建生产者对象，把奶箱对象作为构造方法参数传递，因为在这个类中要调用存储牛奶的操作
    3.创建消费者对象，把奶箱对象作为构造方法参数传递，因为在这个类中要调用获取牛奶的操作4
    4.创建2个线程对象，分别把生产者对象和消费者对象作为构造方法参数传递
    5.启动线程
 */

public class BoxDemo {
    public static void main(String[] args) {
        //创建奶箱对象，这是共享数据区域
       Box b=new Box();

       //创建生产者对象，把奶箱对象作为构造方法参数传递
        Producer p=new Producer(b);

        //创建消费者对象，把奶箱对象作为构造方法参数传递
        Customer c=new Customer(b);

        //创建2个线程对象，分别把生产者对象和消费者对象作为构造方法参数传递
        Thread t1=new Thread(p);
        Thread t2=new Thread(c);

        //启动线程
        t1.start();
        t2.start();


    }
}

评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

放码过来a

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值