精华内容
下载资源
问答
  • 对内置锁的描述错误的是
    千次阅读
    2019-01-05 16:30:08

    什么是内置锁


    • 首先它是由java提供的关键synchronized来实现的,其次synchronized实现的锁在执行完修饰的代码块后自动释放锁的,相对于显示锁必须要手动释放锁所以内置锁也被成为隐式锁。
    • 内置锁是由JVM实现的,jvm能基于synchronized锁做一些优化,比如增加锁的粒度(锁粗化)、锁消除。

    内置锁的特性


    • 相对显示锁来说,内置锁还是过重,因为内置锁是一个互斥锁,不仅读写互斥并且读读也互斥,最多只有一个线程能够获得该锁,当线程A尝试去获得线程B持有的内置锁时,线程A必须等待或者阻塞,直到线程B释放这个锁。
    • synchronized关键字不能继承,父类方法中加了synchronized,在子类中覆盖了这个方法,在子类中的这个方法默认情况下并不是同步的,需要重新加锁。
    • 内置锁是非公平锁,线程在竞争synchronized锁时并不遵循先到等待队列就先获得锁,如果一个线程来请求锁,刚好该锁被释放了,那么这个线程可能会跳过在等待队列中的其它线程直接获得该锁。
    • 内置锁是可重入锁,如果已经获取了一个锁对象,在还没释放时又要执行该锁对象的另一个代码块或方法,则不需要再次给这个对象加锁就可以直接执行。

    内置锁(Synchronized)的使用


    1.synchronized修饰代码块

    • 使用方式如下,将需要同步的代码填入{}内,而关键字synchronized后的()内填入作为锁的对象。任何对象都可以作为锁,除了基本数据类型。
    synchronized (Object) {
    	 // todo
    }
    
    • 范例:
    public class RunnableDemo implements Runnable {
    	static int i = 1;
    
    	@Override
    	public void run() {
    		while (i < 100) {
    			try {
    				synchronized (this) {
    					System.out.println(Thread.currentThread().getName()+"计数:" + i);
    					i++;
    				}
    				Thread.sleep(100);
    			} catch (Exception e) {
    				e.printStackTrace();
    			}
    		}
    	}
    
    	public static void main(String[] args) throws InterruptedException {
    		RunnableDemo runnableSimple=new RunnableDemo();
    		Thread t = new Thread(runnableSimple, "thread-1");
    		Thread t2 = new Thread(runnableSimple, "thread-2");
    
    		t2.start();
    		t.start();
    	}
    }
    

    2.synchronized修饰实例方法

    • 使用方式如下,这时锁的对象就是调用该方法的对象
        public synchronized void method()
        {
           // todo
        }
    
    • 修饰实例方法一样能通过修饰代码块的方式实现,但是这种写法使代码更简洁了。

    • 但是修饰方法会比修饰代码块的执行效率低,因为方法的创建与销毁都是需要耗时的,修饰在方法上,方法的创建与销毁时也都是占用锁的,导致了不必要的浪费。

    • 范例:

    public class RunnableDemo implements Runnable {
    	static int i = 1;
    
    		@Override
    	public void run() {
    		while (i < 100) {
    			this.excuCount();
    		}
    	}
    	
    	public synchronized void excuCount(){
    		while (i < 100) {
    			try {
    				System.out.println(Thread.currentThread().getName()+"计时:" + i);
    				i++;
    				Thread.sleep(100);
    			} catch (Exception e) {
    				e.printStackTrace();
    			}
    		}
    	}
    
    	public static void main(String[] args) throws InterruptedException {
    		RunnableDemo runnableSimple=new RunnableDemo();
    		Thread t = new Thread(runnableSimple, "thread-1");
    		Thread t2 = new Thread(runnableSimple, "thread-2");
    
    		t2.start();
    		t.start();
    	}
    }
    

    synchronized修饰静态方法

    • 使用方式如下,这时锁的对象就是该静态方法所属的类
        public static synchronized void method()
        {
           // todo
        }
    
    • 类也是对象,本质上来说和修饰普通方法没有区别。但是修饰静态方法或修饰代码块时用类作锁的好处是能保证这个代码块被唯一的锁上锁了。

    • 如下面例子中两个线程执行了了两个RunnableDemo实例,但是两个线程在执行excuCount方法时还是同步的,因为他们的锁就是唯一的RunnableDemo.class。把上面两个范例中的main方法同样改为两个不同RunnableDemo实例的线程,他们就不会同步了,因为锁的对象不是同一个RunnableDemo实例对象了。

    • 范例:

    public class RunnableDemo implements Runnable {
    	static int i = 1;
    
    		@Override
    	public void run() {
    		while (i < 100) {
    			this.excuCount();
    		}
    	}
    	
    	public static synchronized void excuCount(){
    		while (i < 100) {
    			try {
    				System.out.println(Thread.currentThread().getName()+"计时:" + i);
    				i++;
    				Thread.sleep(100);
    			} catch (Exception e) {
    				e.printStackTrace();
    			}
    		}
    	}
    
    	public static void main(String[] args) throws InterruptedException {
    		Thread t = new Thread(new RunnableDemo(), "thread-1");
    		Thread t2 = new Thread(new RunnableDemo(), "thread-2");
    
    		t2.start();
    		t.start();
    	}
    }
    
    更多相关内容
  • 文章目录synchronized(内置锁错误的加锁和原因分析 synchronized(内置锁) synchronized 内置锁 Java支持多个线程同时访问一个对象或者对象的成员变量,关键字***synchronizied***可以修饰方法或者代码块的形式...

    并发编程——关于synchronized(内置锁)错误的加锁和原因分析

    关于synchronized(内置锁)

    首先我们需要了解下关于synchronized关键字的一些基本概念。

    • synchronized 内置锁
    • Java支持多个线程同时访问一个对象或者对象的成员变量,关键字 synchronizied 可以修饰方法或者代码块的形式来进行使用,它主要是保证了多个线程同一时刻,只能有一个线程处于方法或者代码块中,它保证了线程对变量的可见性和排他性,又称为 内置锁机制
    • 对象锁和类锁
    • 对象锁是用于对象实例方法或者一个对象实例上的。类锁是用于类的静态方法或者一个类的class对象上的。
    • 一个类可以存在多个对象锁,且不同对象实例的对象锁互不干扰。
    • 每个类只有一个class对象,所以每个类只有一个类锁(个人认为类锁的本质其实还是对象锁,只不过它锁的本质是类的class对象)。
    • 对象锁和类锁之间互不干扰。

    错误的加锁和原因分析

    这里我们以Integer为例。
    首先,我们写一个类来实现线程,代码如下:

    public class TestIntegerSyn {
        static class Worker implements Runnable {
            private Integer i;
            public Worker(Integer i) {
                this.i = i;
            }
            @Override
            public void run() {
                synchronized (i) {
                    Thread thread = Thread.currentThread();
                    System.out.println(thread.getName() + "--@" + System.identityHashCode(i));
                    i++;
                    System.out.println(thread.getName() + "-------" + i + "-@" + System.identityHashCode(i));
                    try {
                        Thread.sleep(3000);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                    System.out.println(thread.getName() + "-------" + i + "--@" + System.identityHashCode(i));
                }
            }
        }
        public static void main(String[] args) throws InterruptedException {
            Worker worker = new Worker(1);
            Thread.sleep(50);
            for (int i = 0; i < 5; i++) {
                new Thread(worker).start();
            }
        }
    }
    
    这里,说明下System.identityHashCode(obj)这个方法,jdk官方文档是这样描述的:标识哈希码,返回给定对象的哈希码,该代码与默认的方法 hashCode() 返回的代码一样,无论给定对象的类是否重写 hashCode()。简单点理解就是无论你是否多次重写hashCode()这个方法。System.identityHashCode(obj)这个方法都会返回原生的哈希码。因此,这里我们可以把System.identityHashCode(obj)返回的值近似认为它是一个内存地址(只能近似认为,它实际不是)。
    

      我们先注释掉run()方法里面第一行和最后一行打印,只查看数据输出的结果的打印。下图是我本地运行结果的几个样图。
    synchronized-demo1
    synchronized-demo2
      我们会发现,虽然运行结果有正确的,但是偶尔也会出现我上面的图一样的情况,缺少不同的中间运行结果,这是为什么呢?然后,我们注意到我们打印输出的“标识哈希码”似乎每次也不一样。这又是为什么呢?这里我们先放开先注释掉的打印,再执行看下,执行结果如下(提示:不同的操作系统以及Java环境都会影响运行的结果,你们运行的结果肯定和我这里展示会不一样):
    synchronized-demo3
      我们发现每次我们在执行 i++ 之前和我们执行之后的“标识哈希码”都会发生变化,这个变化保持的时间是在执行下次 i++ 之前,虽然我们已经对 i 这个Integer 对象的实例加了锁,但这里并没有起作用,这就说明我们这里加锁是无效的。
      为了究其原因,我们吧这个类编译的class对象进行反编译,发现 i++ 这个方法在jdk的源码里面是这样实现的。jdk实现i++
    我们发现在jdk的源码里面它是通过Integer valueOf(int i)这个方法来实现的 i++,然后我们通过看源码发现Integer valueOf(int i)方法jdk的实现方法是这样的:Integer valueOf(int i)实现
    这里我们看到jdk的源码在执行了一系列的操作之后,最后返回了一个new Integer(i)对象,我们都知道new关键字代表你申明了一个新的对象,也就是说无论是怎么对Integer的对象实例加锁,只要调用了valueOf(int i)这个方法,jdk最后都给你返回了一个新的对象,我们加锁的对象也就发生了变化,而synchronized是要让多个线程抢同一个对象的锁,这里每个线程锁的对象都不一样,也就使得这里的加锁无效。
      通过上述demo我们发现对Integer的加锁我们需要去重新考虑直接对Integer对象实例加锁的方式了,其实我们只要明白synchronized关键字锁的对象不发生变化这一点就可以了,这里提供了两种改进方式(仅供参考)。

    1. 申明一个新的Object对象加锁:
    static class Worker implements Runnable {
            private Object obj = new Object();
            private Integer i;
            public Worker(Integer i) {
                this.i = i;
            }
    
            @Override
            public void run() {
                synchronized (obj) {
                    Thread thread = Thread.currentThread();
                    System.out.println(thread.getName() + "--@" + System.identityHashCode(i));
                    i++;
                    System.out.println(thread.getName() + "-------" + i + "-@" + System.identityHashCode(i));
                    try {
                        Thread.sleep(3000);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                    System.out.println(thread.getName() + "-------" + i + "--@" + System.identityHashCode(i));
                }
            }
        }
    
    1. 锁this(this等同于Worker的对象实例)
    static class Worker implements Runnable {
            private Integer i;
            public Worker(Integer i) {
                this.i = i;
            }
    
            @Override
            public void run() {
                synchronized (this) {
                    Thread thread = Thread.currentThread();
                    System.out.println(thread.getName() + "--@" + System.identityHashCode(i));
                    i++;
                    System.out.println(thread.getName() + "-------" + i + "-@" + System.identityHashCode(i));
                    try {
                        Thread.sleep(3000);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                    System.out.println(thread.getName() + "-------" + i + "--@" + System.identityHashCode(i));
                }
            }
        }
    

    展开全文
  • Java为我们提供了内置锁(synchronized)和显式锁(ReentrantLock)两种同步方式。显式锁是JDK1.5引入的,这两种锁有什么异同呢?是仅仅增加了一种选择还是另有其因?本文为您一探究竟。本文转载自:点击跳转内置锁Java...

    synchronized and Reentrantlock

    多线程编程中,当代码需要同步时我们会用到锁。Java为我们提供了内置锁(synchronized)和显式锁(ReentrantLock)两种同步方式。显式锁是JDK1.5引入的,这两种锁有什么异同呢?是仅仅增加了一种选择还是另有其因?本文为您一探究竟。

    本文转载自:点击跳转

    内置锁

    Java内置锁通过synchronized关键字使用,使用其修饰方法或者代码块,就能保证方法或者代码块以同步方式执行。使用起来非常近简单,就像下面这样:

    // synchronized关键字用法示例
    public synchronized void add(int t){// 同步方法
        this.v += t;
    }
    
    public static synchronized void sub(int t){// 同步静态方法
        value -= t;
    }
    public int decrementAndGet(){
        synchronized(obj){// 同步代码块
            return --v;
        }
    }

    这就是内置锁的全部用法,你已经学会了。

    内置锁使用起来非常方便,不需要显式的获取和释放,任何一个对象都能作为一把内置锁。使用内置锁能够解决大部分的同步场景。“任何一个对象都能作为一把内置锁”也意味着出现synchronized关键字的地方,都有一个对象与之关联,具体说来:

    • 当synchronized作用于普通方法是,锁对象是this;
    • 当synchronized作用于静态方法是,锁对象是当前类的Class对象;
    • 当synchronized作用于代码块时,锁对象是synchronized(obj)中的这个obj。

    显式锁

    内置锁这么好用,为什么还需多出一个显式锁呢?因为有些事情内置锁是做不了的,比如:

    1. 我们想给锁加个等待时间超时时间,超时还未获得锁就放弃,不至于无限等下去;
    2. 我们想以可中断的方式获取锁,这样外部线程给我们发一个中断信号就能唤起等待锁的线程;
    3. 我们想为锁维持多个等待队列,比如一个生产者队列,一个消费者队列,一边提高锁的效率。

    显式锁(ReentrantLock)正式为了解决这些灵活需求而生。ReentrantLock的字面意思是可重入锁,可重入的意思是线程可以同时多次请求同一把锁,而不会自己导致自己死锁。下面是内置锁和显式锁的区别:

    • 可定时:RenentrantLock.tryLock(long timeout, TimeUnit unit)提供了一种以定时结束等待的方式,如果线程在指定的时间内没有获得锁,该方法就会返回false并结束线程等待。

    • 可中断:你一定见过InterruptedException,很多跟多线程相关的方法会抛出该异常,这个异常并不是一个缺陷导致的负担,而是一种必须,或者说是一件好事。可中断性给我们提供了一种让线程提前结束的方式(而不是非得等到线程执行结束),这对于要取消耗时的任务非常有用。对于内置锁,线程拿不到内置锁就会一直等待,除了获取锁没有其他办法能够让其结束等待。RenentrantLock.lockInterruptibly()给我们提供了一种以中断结束等待的方式。

    • 条件队列(condition queue):线程在获取锁之后,可能会由于等待某个条件发生而进入等待状态(内置锁通过Object.wait()方法,显式锁通过Condition.await()方法),进入等待状态的线程会挂起并自动释放锁,这些线程会被放入到条件队列当中。synchronized对应的只有一个条件队列,而ReentrantLock可以有多个条件队列,多个队列有什么好处呢?请往下看。

    • 条件谓词:线程在获取锁之后,有时候还需要等待某个条件满足才能做事情,比如生产者需要等到“缓存不满”才能往队列里放入消息,而消费者需要等到“缓存非空”才能从队列里取出消息。这些条件被称作条件谓词,线程需要先获取锁,然后判断条件谓词是否满足,如果不满足就不往下执行,相应的线程就会放弃执行权并自动释放锁。使用同一把锁的不同的线程可能有不同的条件谓词,如果只有一个条件队列,当某个条件谓词满足时就无法判断该唤醒条件队列里的哪一个线程;但是如果每个条件谓词都有一个单独的条件队列,当某个条件满足时我们就知道应该唤醒对应队列上的线程(内置锁通过Object.notify()或者Object.notifyAll()方法唤醒,显式锁通过Condition.signal()或者Condition.signalAll()方法唤醒)。这就是多个条件队列的好处。

    使用内置锁时,对象本身既是一把锁又是一个条件队列;使用显式锁时,RenentrantLock的对象是锁,条件队列通过RenentrantLock.newCondition()方法获取,多次调用该方法可以得到多个条件队列。

    一个使用显式锁的典型示例如下:

    // 显式锁的使用示例
    ReentrantLock lock = new ReentrantLock();
    
    // 获取锁,这是跟synchronized关键字对应的用法。
    lock.lock();
    try{
        // your code
    }finally{
        lock.unlock();
    }
    
    // 可定时,超过指定时间为得到锁就放弃
    try {
        lock.tryLock(10, TimeUnit.SECONDS);
        try {
            // your code
        }finally {
            lock.unlock();
        }
    } catch (InterruptedException e1) {
        // exception handling
    }
    
    // 可中断,等待获取锁的过程中线程线程可被中断
    try {
        lock.lockInterruptibly();
        try {
            // your code
        }finally {
            lock.unlock();
        }
    } catch (InterruptedException e) {
        // exception handling
    }
    
    // 多个等待队列,具体参考[ArrayBlockingQueue](https://github.com/CarpenterLee/JCRecipes/blob/master/markdown/ArrayBlockingQueue.md)
    /** Condition for waiting takes */
    private final Condition notEmpty = lock.newCondition();
    /** Condition for waiting puts */
    private final Condition notFull = lock.newCondition();

    注意,上述代码将unlock()放在finally块里,这么做是必需的。显式锁不像内置锁那样会自动释放,使用显式锁一定要在finally块中手动释放,如果获取锁后由于异常的原因没有释放锁,那么这把锁将永远得不到释放!将unlock()放在finally块中,保证无论发生什么都能够正常释放。

    结论

    内置锁能够解决大部分需要同步的场景,只有在需要额外灵活性是才需要考虑显式锁,比如可定时、可中断、多等待队列等特性。

    显式锁虽然灵活,但是需要显式的申请和释放,并且释放一定要放到finally块中,否则可能会因为异常导致锁永远无法释放!这是显式锁最明显的缺点。

    综上,当需要同步时请优先考虑更安全的更易用的隐式锁。

    展开全文
  • Java中具有通过Synchronized实现的内置锁,和ReentrantLock实现的显示锁,这两种锁各有各的好处,算是互有补充,今天就来做一个总结。 Synchronized 内置锁获得锁和释放锁是隐式的,进入synchronized修饰的代码就...

    Java中具有通过Synchronized实现的内置锁,和ReentrantLock实现的显示锁,这两种锁各有各的好处,算是互有补充,今天就来做一个总结。

    Synchronized

    内置锁获得锁和释放锁是隐式的,进入synchronized修饰的代码就获得锁,走出相应的代码就释放锁。

    Java多线程之内置锁与显示锁

    Java学习交流群:495273252

    通信

    与Synchronized配套使用的通信方法通常有wait(),notify()。

    wait()方法会立即释放当前锁,并进入等待状态,等待到相应的notify并重新获得锁过后才能继续执行;

    notify()不会立刻立刻释放锁,必须要等notify()所在线程执行完synchronized块中的所有代码才会释放。用如下代码来进行验证:

    Java多线程之内置锁与显示锁

    Java多线程之内置锁与显示锁

    Java学习交流群:495273252

    运行结果

    Java多线程之内置锁与显示锁

    Java学习交流群:495273252

    可见读线程开始运行,开始wait过后,写线程才获得锁;写线程走出同步块而不是notify过后,读线程才wait结束,亦即获得锁。所以notify不会释放锁,wait会释放锁。值得一提的是,notifyall()会通知等待队列中的所有线程。

    编码

    编码模式比较简单,单一,不必显示的获得锁,释放锁,能降低因粗心忘记释放锁的错误。使用模式如下:

    Java多线程之内置锁与显示锁

    Java学习交流群:495273252

    灵活性

    • 内置锁在进入同步块时,采取的是无限等待的策略,一旦开始等待,就既不能中断也不能取消,容易产生饥饿与死锁的问题

    • 在线程调用notify方法时,会随机选择相应对象的等待队列的一个线程将其唤醒,而不是按照FIFO的方式,如果有强烈的公平性要求,比如FIFO就无法满足

    性能

    Synchronized在JDK1.5及之前性能(主要指吞吐率)比较差,扩展性也不如ReentrantLock。但是JDK1.6以后,修改了管理内置锁的算法,使得Synchronized和标准的ReentrantLock性能差别不大。

    ReentrantLock

    ReentrantLock是显示锁,需要显示进行 lock 以及 unlock 操作。

    通信

    与ReentrantLock搭配的通行方式是Condition,如下:

    Java多线程之内置锁与显示锁

    Java学习交流群:495273252

    Condition是被绑定到Lock上的,必须使用lock.newCondition()才能创建一个Condition。从上面的代码可以看出,Synchronized能实现的通信方式,Condition都可以实现,功能类似的代码写在同一行中。而Condition的优秀之处在于它可以为多个线程间建立不同的Condition,比如对象的读/写Condition,队列的空/满Condition,在JDK源码中的ArrayBlockingQueue中就使用了这个特性:

    Java多线程之内置锁与显示锁

    Java多线程之内置锁与显示锁

    Java多线程之内置锁与显示锁

    Java学习交流群:495273252

    编码

    Java多线程之内置锁与显示锁

    Java学习交流群:495273252

    相比于Synchronized要复杂一些,而且一定要记得在finally中释放锁而不是其他地方,这样才能保证即使出了异常也能释放锁。

    灵活性

    • lock.lockInterruptibly() 可以使得线程在等待锁支持响应中断;lock.tryLock() 可以使得线程在等待一段时间过后如果还未获得锁就停止等待而非一直等待。有了这两种机制就可以更好的制定获得锁的重试机制,而非盲目一直等待,可以更好的避免饥饿和死锁问题

    • ReentrantLock可以成为公平锁(非默认的),所谓公平锁就是锁的等待队列的FIFO,不过公平锁会带来性能消耗,如果不是必须的不建议使用。这和CPU对指令进行重排序的理由是相似的,如果强行的按照代码的书写顺序来执行指令,就会浪费许多时钟周期,达不到最大利用率

    性能

    虽然Synchronized和标准的ReentrantLock性能差别不大,但是ReentrantLock还提供了一种非互斥的读写锁,

    也就是不强制每次最多只有一个线程能持有锁,它会避免“读/写”冲突,“写/写”冲突,但是不会排除“读/读”冲突,

    因为“读/读”并不影响数据的完整性,所以可以多个读线程同时持有锁,这样在读写比较高的情况下,性能会有很大的提升。

    下面用两种锁分别实现的线程安全的linkedlist:

    Java多线程之内置锁与显示锁

    Java多线程之内置锁与显示锁

    Java学习交流群:495273252

    读写锁测试代码:

    Java多线程之内置锁与显示锁

    Java多线程之内置锁与显示锁

    Java学习交流群:495273252

    同步锁测试代码:

    Java多线程之内置锁与显示锁

    Java多线程之内置锁与显示锁

    Java学习交流群:495273252

    结果:

    Java多线程之内置锁与显示锁

    Java学习交流群:495273252

    可见读写锁的确是优于纯碎的互斥锁

    总结

    内置锁最大优点是简洁易用,显示锁最大优点是功能丰富,所以能用内置锁就用内置锁,在内置锁功能不能满足之时在考虑显示锁。

    关于两种锁,目前接触到的就是这么多,总结不到位之处,欢迎拍砖。

    学习Java的同学注意了!!!

    学习过程中遇到什么问题或者想获取学习资源的话,欢迎加入Java学习交流群495273252,我们一起学Java!

    展开全文
  • 双重检查(Double-Checked Locking)被广泛用于多线程环境下实现延迟初始化实例,但是它其实是有缺陷的。
  • boost库asio错误

    千次阅读 2018-10-24 16:53:55
    boost库asio常见错误码 boost::asio::error::bad_descriptor (10009) 在一个已经关闭了的套接字上执行async_receive() boost::asio::error::operation_aborted (995) 正在async_receive()异步任务等待时,本端关闭...
  • 语法错误 - 如何处理python中的“意外缩进”?如何纠正python中的“意外缩进”错误?15个解决方案116 votesPython在行的开头使用间距来确定代码块何时开始和结束。 你可以得到的错误是:意外的缩进。 这行代码在开头...
  • 常见错误

    千次阅读 2021-03-19 13:55:35
    error code(错误代码)=0是操作成功完成。 error code(错误代码)=1是功能错误。 error code(错误代码)=2是系统找不到指定的文件。 error code(错误代码)=3是系统找不到指定的路径。 error code(错误代码...
  • JSP 九大内置对象及四个作用域详解

    万次阅读 多人点赞 2019-01-18 10:29:13
    JSP中一共预先定义了9个内置对象:内置对象,又叫做隐含对象,不需要预先声明就可以在脚本代码和表达式中随意使用 request、response、session、application、out、pagecontext、config、page、exception ...
  • java知识

    2021-09-15 14:50:24
    ##代码 JIT中设置热点代码阈值的参数是? -XX:CompileThreshold=500 修改JIT编译阈值为500 需要GC的区域:Java堆和方法区。...A 错误流 B 监控流 C 输出流 D 输入流 哪些是同步的? A. TreeSet B. H
  • 在很多时候都会遇到错误, 还会带有一些 Error Code , 比如在各种网络请求, 文件操作, cookie 错误等各种错误的代码和错误代码对应的含义. 以下目录为 SOCKS4 Errors, SOCKS5 Errors, FTP Errors, HTTP Errors, ...
  • Mysql错误编码和解释表

    万次阅读 2017-09-19 20:58:54
    Mysql错误编码和解释表1.错误消息的组成一共由三部分组成 1.mysql数字错误代码,这个数字的mysql的特定值,不可以移植到其它数据库系统。 2.一个五位长度的sqlstate值,这些...3.错误的消息描述 2.一些额外的说明 如果
  • MySQL 5.7 服务端 错误码 (机翻)

    千次阅读 2020-09-17 17:03:19
    MySQL服务器将一些错误消息写入其错误日志,并将其他错误消息发送到客户端程序。 写入错误日志的服务器端错误消息示例: 2018-09-26T14:46:06.326016Z 0 [Note] Skipping generation of SSL certificates as options...
  • 数据库乐观和悲观的理解和实现(转载&总结)

    万次阅读 热门讨论 2018-05-11 10:36:08
    乐观是一种思想,具体实现是,表中有一个版本字段,第一次读的时候,获取到这个字段。处理完业务逻辑开始更新的时候,需要再次查看该字段的值是否和第一次的一样。如果一样更新,反之拒绝。之所以叫乐观,因为这...
  • Spark2.1.0之内置RPC框架

    千次阅读 2018-06-27 09:27:34
    由此可见,ClientPool实际是由TransportClient的数组构成,而locks数组中的Object与clients数组中的TransportClient按照数组索引一一对应,通过每个TransportClient分别采用不同的,降低并发情况下线程间对锁的...
  • VC中GetLastError() 错误代码的含义

    千次阅读 2019-02-15 17:12:48
    VC中GetLastError() 错误代码的含义  各种错误代码的含义    〖0〗-操作成功完成。  〖1〗-功能错误。  〖2〗-系统找不到指定的文件。  〖3〗-系统找不到指定的路径。  〖4〗-系统无法打开文件。  ...
  • 数据库错误码大全

    千次阅读 2021-06-05 02:30:10
    1 功能错误。 2 系统找不到指定的文件。 3 系统找不到指定的路径。 4 系统无法打开文件。 5 拒绝访问。 6 句柄无效。 7 存储控制块被损坏。 8 存储空间不足,无法处理此命令。 9 存储控制块地址无效。 10 环境错误。...
  • 本文为明德扬原创及录用文章,转载请注明出处! 作者:秦红锴 一、项目背景概述 随着生活质量的不断提高,加强家庭防盗安全变得非常重要,但...随看人们高科技产品也越来越推崇,在当今社会科技的高度集中和创新...
  • 在讨论分布式前,我们先假设一个业务场景: 2.1.业务场景 我们假设一个这样的业务场景: 在电商中,用户购买商品需要扣减商品库存,一般有两种扣减库存方式: 下单减库存 优点:用户体验好,下
  • 高并发线程//内存处理模型

    万次阅读 2021-10-04 13:08:56
    文章目录与线程一、进程/线程的基本介绍进程线程1 线程的调度与时间片2 优先级3 生命周期进程与线程的区别二、线程的使用2.1 Thread类的介绍2.2 创建线程的方法ThreadRunnableCallableFuture利用线程池总结2.3 为...
  • 牛逼!Java 从入门到精通,超全汇总版

    万次阅读 多人点赞 2021-05-06 19:40:33
    除此以外,本书在必要时还 Java 语言的功能进行补充说明,以加深读者 Java 的理解,在学习设计模式的同时也在复习 Java。 上面这两本书非常适合初学者学习设计模式 设计模式 这本书结合设计实作例从面向对象的...
  • 在很多时候都会遇到错误, 还会带有一些 Error Code , 比如在各种网络请求, 文件操作, cookie 错误等各种错误的代码和错误代码对应的含义. 以下目录为 SOCKS4 Errors, SOCKS5 Errors, FTP Errors, 
  • 基于Arduino的密码+指纹智能(LCD1602显示器)

    万次阅读 多人点赞 2020-09-30 10:26:54
    我们Markdown编辑器进行了一些功能拓展与语法支持,除了标准的Markdown编辑器功能,我们增加了如下几点新功能,帮助你用它写博客: 全新的界面设计 ,将会带来全新的写作体验; 在创作中心设置你喜爱的代码高亮样
  • 10013错误解决方法 10013错误为以一种访问权限不允许的方式做了一个访问套接字的尝试。 错误原因: 1、SOCKET socketRaw = socket(AF_INET,SOCK_RAW,IPPROTO_ICMP) SOCK_RAW需要root权限。 2、若试图在sendto或...
  • GreenPlum表经历

    千次阅读 2020-06-03 15:01:14
    PL / pgSQL异常块中获得的也是如此:从该块进行的错误转义将释放在其中获取的。 Once acquired, a lock is normally held till end of transaction. But if a lock is acquired after establishing a savepoint,...
  • SP刷机工具错误信息

    千次阅读 2021-11-15 13:34:18
    它是一个非常容易使用的工具,但在您的刷机体验中,您一定会在某些时候遇到一个或另一个错误。本指南专门列出您在使用 SP Flash 工具时可能遇到的错误/问题、它们的含义/指示以及您可以采取哪些步骤来修复/解决它们...
  • 深入浅出ReentrantLock(可重入)

    千次阅读 多人点赞 2019-11-08 09:48:53
    在Java 5.0之前,在协调共享对象的访问的时可以使用的机制只有synchronized 和 volatile。Java 5.0 增加了一种新的机制:ReentrantLock 。与之前提到过的机制相反,ReentrantLock 并不是一种替代内置加锁的方法,...
  • 1、Lock接口以及ReentrantLock可重入

    千次阅读 2020-08-10 17:21:22
    Java并发编程简析 并发编程在Java实际开发中,占有举足轻重...自JDK1.5开始,Java提供了Lock接口,实现的机制,相对于Synchronize,Lock更为轻量级、同时增加了的可操作性。 public interface Lock { void lock()
  • Redis是一款基于键值的NoSQL数据库,它的值支持多种数据结构: 字符串(strings)、哈希(hashes)、列表(lists)、集合(sets)、有序集合(sorted sets)等。 • Redis将所有的数据都存放在内存中,所以它的读写性能十分...
  • Java多线程|同步与机制

    千次阅读 2016-06-03 20:06:43
    总结 Java「与同步」机制。

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 28,461
精华内容 11,384
关键字:

对内置锁的描述错误的是