java高级编程--多线程的使用

最新推荐文章于 2024-08-09 09:30:00 发布
最新推荐文章于 2024-08-09 09:30:00 发布
阅读量145 收藏
点赞数
分类专栏： java 文章标签： java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_46000014/article/details/107271624
版权

创建多线程的两种方式

继承Thread类的方式

一：实现步骤

  1. 创建一个继承股Thread的子类
  2. 重写Thread类的run（）方法
  3. 创建Thread类的子类对象
  4. 通过子类对象调用strat（）开启线程并调用run（）方法；
/**
 * @author 宇戰天
 *
 * @description：遍历1-40之内的偶数
 *
 * @create2020-07-10-16:22
 */


//1.创建一个继承与Thread的子类
class MyThread extends Thread {
    //2.重写Thread的run()方法

    @Override
    public void run() {

        for (int i = 0; i < 40; i++) {
            if(i%2 ==0){
                System.out.println(Thread.currentThread().getName()+":"+i);
            }

        }
    }
}
public class ThreadTest {

    public static void main(String[] args) {
        //3创建Thread的子类对象
        MyThread t1 = new MyThread();

        MyThread t2 = new MyThread();

        //4通过此对象实例调用start()方法开启线程
        t1.start();

        t2.start();

        //创建对比主线程
        for (int i = 0; i < 40; i++) {
            if (i % 2 ==0){
                System.out.println(Thread.currentThread().getName()+":"+i+"  main");
            }

        }




    }
}

运行结果

在这里插入图片描述

线程的常用方法

  1. start(): 启动线程，并执行对象的run()方法；
  2. run(): 线程在被调度时执行的操作；
  3. getName(): 返回线程的名称；
  4. currentThread：返回执行当前代码的线程；
  5. setName(String name):设置该线程名称；
/**
 * @author 宇戰天
 * @description：
 * 方式一：
 * 设置当前线程的名字setName();
 * 为子线程时对象实例.setName(线程名);设置该线程名
 * 在main方法中设置线程名时需要先通过currentThread()获取当前代码的线程在设置线程名
 * Thread.currentThread().setName("线程名");
 * 方式二：
 * 在子类对象中添加Thread(String)的构造器在实例化线程时直接初始化线程名
 *
 * @create2020-07-10-18:42
 */
public class SetNameMethod {

    public static void main(String[] args) {
        //实例化Thread的子类对象
        UpdateThreadName u1 = new UpdateThreadName();

        u1.setName("我是子线程");

        //子类对象调用start()开启线程并调用器run（）方法
        u1.start();

        //添加主线程对比项
        Thread.currentThread().setName("我是主线程");

        for (int i = 0; i < 20; i++) {

            if (i % 2 == 0){
                System.out.println(Thread.currentThread().getName() + " " + i);
            }
        }

    }
}


//创建Thread的子类对象
class UpdateThreadName extends Thread{

    //提供构造器

    public UpdateThreadName() {
    }

    public UpdateThreadName(String name) {
        super(name);
    }
//重写run();
    @Override
    public void run() {
        for (int i = 0; i < 20; i++) {

            if (i % 2 == 0){
                System.out.println(Thread.currentThread().getName() + " " + i);
            }
        }
    }
}

运行结果
在这里插入图片描述
6. yield（）；释放当前cpu 的执行权限

/**
 * @author 宇戰天
 * @description：
 * yield()释放当前CPU的执行权限
 * @create2020-07-10-19:03
 */
public class UserYield {

    public static void main(String[] args) {

        YieldMethod y1 = new YieldMethod();
        y1.setName("子线程");
        y1.start();

        for (int i = 0; i < 50; i++) {

            if (i % 2 != 00){

                System.out.println(Thread.currentThread().getName() + "  " + i);

            }

        }

    }

}


class YieldMethod extends Thread{


    @Override
    public void run() {

        for (int i = 0;i <100;i++){

            if (i % 2 ==0){
                System.out.println(Thread.currentThread().getName() + "  " + i);
            }
            if (i ==20){
                yield();
            }
        }

    }
}
  1. join()：当某个程序执行流中调用其他线程的join() 方法时，调用线程将被阻塞，直到join() 方法加入的join 线程执行完为止；
  2. isAlive()：返回boolean，判断线程是否还活着
  3. sleep(long millis)：令当前活动线程在指定时间段内放弃对CPU控制,使其他线程有机会被执行,时间到后重排队。
/**
 * @author 宇戰天
 * @description：
 * join()方法在线程a中调用线程b的join()方法，此时线程a就进入停止状态知道线程b执行完为止
 *sleep();让当前线程休眠，只等时间内为阻塞状态
 * isAlive()判断当前线程是否存活
 * @create2020-07-10-19:28
 */
public class JoinMethod {

    public static void main(String[] args) {

        JoinIn method23 = new JoinIn();

        method23.setName("线程b");
        method23.start();

        Thread.currentThread().setName("线程a");
        for (int i = 0; i < 50; i++) {

            System.out.println(Thread.currentThread().getName() + "  " + i);
            if (i==25){
                try {
                    //在在线程a中调用线程b的join();
                    method23.join();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }

            }

        }
        //判断当前线程是否存活
        System.out.println(method23.isAlive());
    }
}


class JoinIn extends Thread{


    @Override
    public void run() {
        for (int i = 0;i<50;i++){

            //当前线程休眠时间
            try {
                sleep(100);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }

            System.out.println(Thread.currentThread().getName() + "   " + i);
        }
    }
}
线程的优先级

线程的优先级等级

  • MAX_PRIORITY：10
  • MIN _PRIORITY：1
  • NORM_PRIORITY：5（默认优先级）
    如何设置线程的优先级
  • getPriority() ：返回线程优先值
  • setPriority(intnewPriority) ：改变线程的优先级
    注意
  • 线程创建时继承父线程的优先级；
  • 低优先级只是获得调度的概率低，并非一定是在高优先级线程之后才被调用

创建线程的方式二：实现Runnable接口

实现思路
1.创建一个实现Runnable接口的实现类；
2.实现类实现Runnable中的抽象方法run();
3.创建实现类的对象；
4.将此实现类作为参数传递给Thread的构造器中并创建Thread类的对象；
5.通过Thread类的对象调用start()启动线程并调用Runnable类型的target的run();

/**
 * @author 宇戰天
 * @description：
 * 创建多线程的第二种方式：实现Runnable接口
 * 1.创建一个实现Runnable接口的实现类；
 * 2.实现类实现Runnable中的抽象方法run();
 * 3.创建实现类的对象；
 * 4.将此实现类作为参数传递给Thread的构造器中并创建Thread类的对象；
 * 5.通过Thread类的对象调用start()启动线程并调用Runnable类型的target的run();
 * @create2020-07-10-21:47
 */

//1.创建一个实现Runnable接口的实现类
class Thread2 implements Runnable{
        //2.实现类实现Runnable中的抽象方法run();
    @Override
    public void run() {
        for (int i = 0; i < 40; i++) {

            System.out.println(Thread.currentThread().getName() + " " + i);

        }
    }
}
public class ImplementsThreadSecondMethod {

    public static void main(String[] args) {
        //3.创建实现类的对象
        Thread2 t2 = new Thread2();
        //4.将此实现类作为参数传递给Thread的构造器中并创建Thread类的对象
        Thread thread = new Thread(t2);
        thread.setName("线程");
        //5.通过Thread类的对象调用start()启动线程并调用Runnable类型的target的run();
        thread.start();
    }


}

线程安全

在java中我们通过同步机制来解决线程的安全问题；解决线程通行常用的三种方法分别为lock锁方式、同步代码块、同步方法

一：同步代码块方式解决线程安全问题
  1. 定义
synchronized (同步监听器){	
		
			//需要被同步的代码
}
  1. 说明
    1. 操作共享数据的代码为需要被同步的代码
    2. 共享数据多个线程共同操作的变量
    3. 同步监听器：俗称锁任何一个对象都可以充当锁，但是多个线程必须共用同一个锁。

实现Runnable接口方式

/**
 * @author 宇戰天
 * @description：
 *
 *通过实现Runnable接口方式创建三个线程实现卖票功能
 * 步骤：
 * 1.创建一个Runnable接口的类；
 * 2.实现Runnable中的抽象方法run（）；
 * 3.创建实现对象
 * 4.创建Thread对象，此将实现Runnable的子类对象作为参数传递到Thread的构造器中；
 * 5.通过Thread对象调用start（）开启线程
 *
 * 用同步代码块方式解决线程安全问题
 *       synchronized(监听器) {
 *
 *              需要同步打代码
 *     }
 * @create2020-07-12-12:31
 */

public class SellTicketTest {

    public static void main(String[] args) {
        //3.创建实现的对象
        TicketWindow chengDu = new TicketWindow();

        //4.创建Thread对象，此将实现Runnable的子类对象作为参数传递到Thread的构造器中

        Thread sellWindows1 = new Thread(chengDu);
        Thread sellWindows2 = new Thread(chengDu);
        Thread sellWindows3= new Thread(chengDu);

        //设置线程名
        sellWindows1.setName("一号窗口");
        sellWindows2.setName("二号窗口");
        sellWindows2.setName("三号窗口");

        //5.通过Thread对象调用start（）开启线程
        sellWindows1.start();
        sellWindows2.start();
        sellWindows3.start();

    }


}
//1.传建一个实现Runnable接口的子类
class TicketWindow implements  Runnable{
    //售票数量（多个线程共享此数据）
    private  int ticket =100;

    //定义同步监听器-->锁
    Object obj = new Object();

    //2.重写Runnable中的抽象方法run（）
    @Override
    public void run() {
        while (true){

            synchronized(obj) {

                if (ticket >0){
    //一秒后开启线程为其他线程执行抢占CPU资源提供条件
                    try {
                        Thread.sleep(1000);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }

                    System.out.println(Thread.currentThread().getName() + " 卖票，票的编号为：" + ticket);

                    ticket--;
                }else{
                    break;
                }
            }

        }
    }
}

继承Thread类

**
 * @author 宇戰天
 * @description：
 * 通过继承Thread方式创建三个进程实现卖票功能
 * 1.创建继承Thread的子类；
 * 2.重写T和read中的run（）;
 * 3.创建Thread的子类对象；
 * 4.通过子类对象调用start（）方法开启线程
 *
 * 通过synchronized(同步监视器){
 *
 *     需要被同步的代码
 * }
 * 解决线程安全问题
 * @create2020-07-12-13:28
 */
public class SellTicketTest1 {

    public static void main(String[] args) {
        //3.创建Thread类的子类的对象
        sellWindows1 t1 = new sellWindows1();
        sellWindows1 t2 = new sellWindows1();
        sellWindows1 t3 = new sellWindows1();

        //更改线程名
        t1.setName("窗口1");
        t2.setName("窗口2");
        t3.setName("窗口3");

        //4.通过此子类对象调用start（）开启线程
        t1.start();
        t2.start();
        t3.start();
    }
}

//1.创建一个继承于Thread的子类
class sellWindows1 extends  Thread{
    //所有对象共享此变量
    private static int  ticket = 100;
    //创建同步锁
    private static Object obj = new Object();
//2.重写Thread中的run
    @Override
    public void run() {

        while (true){

            synchronized (obj){
                if (ticket>0){

                        //提高其他线程出现的几率
                    try {
                        Thread.sleep(1000);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                    System.out.println(Thread.currentThread().getName() + " 卖票，票号为：" + ticket);
                    ticket--;

                }else{
                    break;
                }
            }

        }
    }
}
同步方法解决线程安全问题

实现Runnable接口方式

/**
 * @author 宇戰天
 * @description：
 *
 * 同步方法解决线程安全问题
 * @create2020-07-12-14:13
 */
public class SellTicketTest3 {

    public static void main(String[] args) {
        //3.创建实现的对象
        TicketWindow3 chengDu = new TicketWindow3();

        //4.创建Thread对象，此将实现Runnable的子类对象作为参数传递到Thread的构造器中

        Thread sellWindows1 = new Thread(chengDu);
        Thread sellWindows2 = new Thread(chengDu);
        Thread sellWindows3 = new Thread(chengDu);

        //设置线程名
        sellWindows1.setName("一号窗口");
        sellWindows2.setName("二号窗口");
        sellWindows2.setName("三号窗口");

        //5.通过Thread对象调用start（）开启线程
        sellWindows1.start();
        sellWindows2.start();
        sellWindows3.start();

    }


}
//1.传建一个实现Runnable接口的子类
class TicketWindow3 implements  Runnable{
    //售票数量（多个线程共享此数据）
    private  int ticket =100;


    //2.重写Runnable中的抽象方法run（）
    @Override
    public void run() {
        while (true) {

            show();

        }
    }
    private synchronized void show(){

        if (ticket >0){
            //一秒后开启线程为其他线程执行抢占CPU资源提供条件
            try {
                Thread.sleep(100);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }

            System.out.println(Thread.currentThread().getName() + " 卖票，票的编号为：" + ticket);

            ticket--;
        }
    }

}

继承Thread子类的方式

/**
 * @author 宇戰天
 * @description：
 * @create2020-07-12-14:35
 */
public class sellTicketTest4 {

    public static void main(String[] args) {
        //3.创建Thread类的子类的对象
        sellWindows4 l1 = new sellWindows4();
        sellWindows4 l2 = new sellWindows4();
        sellWindows4 l3 = new sellWindows4();

        //更改线程名
        l1.setName("窗口1");
        l2.setName("窗口2");
        l3.setName("窗口3");

        //4.通过此子类对象调用start（）开启线程
        l1.start();
        l2.start();
        l3.start();
    }
}

//1.创建一个继承于Thread的子类
class sellWindows4 extends  Thread{
    //所有对象共享此变量
    private static int  ticket = 100;

    //2.重写Thread中的run
    @Override
    public void run() {

        while (true){

            show();

        }
    }

    private static synchronized  void show(){
        if (ticket>0){

            //提高其他线程出现的几率
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println(Thread.currentThread().getName() + " 卖票，票号为：" + ticket);
            ticket--;

        }

    }
}
使用lock锁方式
/**
 * @author 宇戰天
 * @description：
 * 使用lock方式解决卖票中个线程安全问题
 * @create2020-07-12-15:51
 */
//创建实现Runnable接口的实现子类
class windowsLock implements Runnable {


    private int  ticket = 100;

    //实例化ReentrantLock

     private  ReentrantLock lock1 = new ReentrantLock();

     //重写实现子类的run方法
    @Override
    public void run() {


        while(true){
            try{

                //调用锁定的方法lock()
                lock1.lock();

                if (ticket >0){

                    try {
                        Thread.sleep(1000);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }

                    System.out.println(Thread.currentThread().getName() + " 售票，票号为：" + ticket);
                    ticket--;
                }


            }finally{

                //调用解锁方式
                lock1.unlock();
            }


        }

    }
}

public class UseLockRelolveSafelty {

    public static void main(String[] args) {
        //创建实现子类的对象

        windowsLock w2 = new windowsLock();

        //将此实现子类对象传给Thread，创建Thread子类
        Thread q1 =new Thread(w2);
        Thread q2 =new Thread(w2);
        Thread q3 =new Thread(w2);

        //设置线程名
        q1.setName("窗口1");
        q2.setName("窗口2");
        q3.setName("窗口3");

        //调用start开启线程
        q1.start();
        q2.start();
        q3.start();
    }



}

线程通信

wait() 与notify() 和notifyAll()

  • wait()：令当前线程挂起并放弃CPU、同步资源并等待，使别的线程可访问并修改共享资源，而当前线程排队等候其他线程调用notify()或notifyAll()方法唤醒，唤醒后等待重新获得对监视器的所有权后才能继续执行
  • notify()：唤醒正在排队等待同步资源的线程中优先级最高者结束等待
  • notify()：唤醒正在排队等待同步资源的线程中优先级最高者结束等待
    注意
    这三个方法只有在synchronized方法或synchronized代码块中才能使用
/**
 * @author 宇戰天
 * @description：
 *生产者和消费者问题
 * 生产者(Productor)将产品交给店员(Clerk)，而消费者(Customer)从店员处取走产品，
 * 店员一次只能持有固定数量的产品(比如:20），如果生产者试图生产更多的产品，店员
 * 会叫生产者停一下，如果店中有空位放产品了再通知生产者继续生产；如果店中没有产品
 * 了，店员会告诉消费者等一下，如果店中有产品了再通知消费者来取走产品。
 * @create2020-07-12-17:49
 */
//被共享的数据
class Clerk{

    private  int productNum = 0;
//生产产品的方法
    public synchronized void addProduct() {

        if(productNum<20){
            productNum++;
            System.out.println(Thread.currentThread().getName() + "开始生产第：" + productNum + "产品");
//唤醒消费者
            notify();

        }else{

            try {
                wait();
            } catch (Exception e) {
                e.printStackTrace();
            }
        }
    }


//    售卖商品的方法
    public synchronized void sellProductor() {

        if (productNum>0){

            System.out.println(Thread.currentThread().getName() + "购买了第" + productNum + "个产品");
            productNum--;
//唤醒生产者
            notify();
        }else{

            try {
                wait();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }
}


//生产者线程
class Productor extends Thread{
    private Clerk clerk;

    public Productor(Clerk clerk) {
        this.clerk = clerk;
    }

    @Override
    public void run() {
        System.out.println(Thread.currentThread().getName() + "工厂开始生产产品 ......");
        while(true){
            try {
                Thread.sleep(50);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            clerk.addProduct();
        }
    }
}


//消费者线程
class Customer extends Thread{

    private Clerk clerk;

    public Customer(Clerk clerk) {
        this.clerk = clerk;
    }

    @Override
    public void run() {
        System.out.println(Thread.currentThread().getName() + "开始购买产品......");

        while(true){

            try {
                Thread.sleep(3000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }

            clerk.sellProductor();
        }


    }

}
public class CustomerAndProduct {


    public static void main(String[] args) {
        Clerk clerk = new Clerk();


//        创建生产工厂

        Productor p1 = new Productor(clerk);
        p1.setName("工厂1");

//        创建生产者对象实例
        Customer c1 = new Customer(clerk);
        c1.setName("消费者1");

        Customer c2 = new Customer(clerk);
        c2.setName("消费者2");
//    通过对象调用start()方法开启线程
        p1.start();
        c1.start();
        c2.start();
    }

}
宇戰天0910
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
Java 高级编程 学习路线
liujian8654562的博客
09-17 3677
关注https://blog.csdn.net/person_limit微博，共同学习 金三银四的跳槽热潮即将过去，在这两个月的跳槽的旺季中，作为互联网行业的三大巨头，百度、阿里巴巴、腾讯对于互联网人才有很大的吸引力，他们的员工也是众多互联网同行觊觎的资深工程师、管理者人选。 下面我总结了进入这三家公司你所需掌握的技能： 阿里巴巴篇 扎实的计算机专业基础，包括算法和数据结...
4JAVA编程高级-多线程编程
07-30
### JAVA编程高级-多线程编程 #### 一、多线程简介 多线程编程是一种软件技术，它允许在单个程序内并发执行多个控制流。这种技术极大地提高了程序的执行效率和响应能力，特别是在现代多核处理器环境中。本文档主要...
JAVA高级编程资料
07-20
包括JAVA高级编程中所涉及的多线程、网络编程、文件与流、集合类等等详细资料
Java高级编程知识总结及复习（三）
MELF晓宇的博客
07-01 1290
Java高级编程知识总结及复习（三） 1、异常处理 try-catch-finally异常捕获处理机制 public class Demo101 { public static void main(String[] args) { int x = 10; int y = 0; try{ System.out.println(x / y); }catch (ArithmeticException e){
Java高级编程之集合
哈哈L先生
08-14 390
Java集合 一、集合框架的概述 1. 集合与数组存储数据概述 集合、数组都是对多个数据进行存储操作的结构，简称Java容器。 说明：此时的存储，主要指的是内存层面的存储，不涉及到持久化的存储（即硬盘存储，比如数据库中)。另外，对于存储的数据类型，数组可以存储基本数据类型和引用数据类型，而Java集合只能存储引用数据类型。 2.数组 2.1 存储的特点： 一旦初始化以后，其长度就确定了。 数组一旦定义好，其元素的类型也就确定了。我们也就只能操作指定类型的数据了。 2.2 存储的弊端： 一旦初始化以后，
java高级编程
wangprince2017
12-15 6071
（一）课程描述 Java高级编程是一门面向计算机专业的专业任选课，其具有实践性强、应用广泛、功能强大等特点，对于学生职业发展和提高社会信息化水平，具有重要意义。Java Web开发是Java 开发技术中的一个重要的组成部分，在B/S开发领域占有一席之地。本课程针对Java Web开发编程进行了详细的讲解，以简单的、通俗易懂的案例，循序渐进地逐步引领读者从基础到各个知识点进行学习。本课程涵盖了主流的Java Web开发技术和开发工具，内容包括了Java集合框架、反射技术、Filter、Listener、EL
Java-Java线程编程教程
11-14
在进行Java多线程编程时，要遵循良好的编程实践，如避免长时间持有锁、合理设置线程优先级、使用并发集合（如ConcurrentHashMap、CopyOnWriteArrayList等）以减少同步开销，以及及时关闭不再使用的线程池。...
java课件-5-多线程
01-10
在压缩包的文件列表中，"5_多线程"可能包含有关多线程编程的具体示例、练习和解决方案，比如线程的创建、同步机制的使用、并发工具的实践以及并发问题的处理策略。这些内容对于深入理解和掌握Java并发编程至关重要。...
Java-JUC-多线程 进阶
07-05
Java-JUC-多线程进阶resources是 Java 并发编程的高级课程，涵盖了 Java 中的并发编程概念、线程安全、锁机制、集合类、线程池、函数式接口、Stream流式计算等多个方面。 什么是JUC JUC（Java Utilities for ...
Java高级特性 - 多线程练习题.zip
06-07
在这个"Java高级特性 - 多线程练习题.zip"中，我们可以看到两个文件，分别是"顺序输出.txt"和"售票窗口.txt"，它们很可能是用来展示或测试多线程编程概念的例子。 1. **线程的创建与启动** Java中创建线程主要有两...
java高级编程技巧
weixin_30888027的博客
05-13 76
1. boolean a= b==null;这句话很亮。 public class Test { public static void main(String[] args) { String b="aaaa"; boolean a= b==null; a=b==null?true:false; ...
java高级编程之深入
网站开发初中级代码参考-转载
09-18 181
首先从基础开始， 静态方法的导入： 包名.类名.静态属性|静态方法|； 这种方法比较简单，有利于减少代码，但是必须记住每个包里的类的方法和属性；这是前提，如果不能记清的话，也只能按以前的方法来，也没有太大的区别； 举例： importjava.lang.System,out;//写完之后，底下的输出就可以直接用out可以了； pubicstaticvoidmian(Stringargs...
JAVA高级编程基础自学笔记---泛型
测试领域专家，多领域测试技术、管理、工具都略懂，略懂一二
08-13 202
这个知识点比较简单！ 别人转过来集合给你用，但是你不确定别人用什么类型，你就不知道强制转换成什么类型，你调用的时候要一个个试，不然你就得问，好多。 基本概念： 顾名思义：广泛的类型，通常情况下集合中可以存放类型的对象，本质上是将这些对象全部看做Object类型放入，因此集合中取出元素时也是Object类型，为了表达元素最真实的数据类型就需要强制类型转换，而强制类型转换可能发生类型转换异常； 为了避免上述错误的发生，从jdk1.5开始提出泛型机制，也就是在集合名称的右侧使用<数据类型..
Android面试（一）
抓鱼的猫的博客
09-02 271
说明这次就先给大家展示一下一些简单的Android面试题吧，以后会持续更新，希望对有需要的朋友有帮助。面试题sp操作apply和commit的区别：1. apply没有返回值而commit返回boolean表明修改是否提交成功 2. apply是将修改数据原子提交到内存, 而后异步真正提交到硬件磁盘, 而commit是同步的提交到硬件磁盘，因此，在多个并发的提交commit的时候，他们会等
Java高级编程-- 9.2知识点
wuwndj的博客
09-04 220
CUI 图形用户接口 swing组件继承关系 Swing顶级容器 JFrame、JDialog、JApplet 1、JFrame类 实现窗口基本功能 例 ： import javax.swing.JFrame; import javax.swing.SwingUtilities; public static void creatAndShowGUI() { JFrame jframe=new JFrame(“jFrameTest”); jframe.setDefaultCloseOperation(JFr
Java高级编程基础知识
十七博客
04-05 634
2020-04-05，首发，持续更新直至该章节学习结束。 一、Java多线程编程 1、继承Thread类实现多线程 Java中提供了一个java.lang.Thread的程序类，那么一个类只要继承了此类，就表示这个类为线程的主体类。（需要覆写run()方法，这个方法属于线程的主方法） 多线程要执行的功能都应该在run()方法中进行定义。需要说明的是，在正常情况下，如果要使用一个类中的方法，一定要产...
C++ - 函数重载
jiaowenjie的专栏
08-06 301
/打印的是第二个函数的地址。//打印的是第一个函数的地址。-> 重载函数在本质上是相互独立的不同函数。-> 函数返回值不能作为函数重载的依据。-> 重载函数的函数类型不同。**3.函数默认参数和函数重载****函数重载的注意事项：****4.函数重载的本质**
时光不等人：java每日一练
m0_67187271的博客
08-05 1067
时光悄然流逝，不等人。技术亦不会自来门前，唯有勤奋学习，方能抓住时代的脉搏。
Java面试篇（JVM相关专题）
最新发布
聂可以的博客
08-09 2360
Java面试篇（JVM相关专题）
Java高级编程：数据库、多线程与网络
Java的多线程机制允许程序并发执行，提高系统效率。线程可以独立于主线程执行任务，通过Thread类或实现Runnable接口来创建。理解和掌握线程同步、线程通信（如wait()、notify()和notifyAll()）是实现高效并发程序的...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值