我喜欢你喜欢我的歌

Thread sleep() 和 wait()

2018-04-01

Thread sleep() 和 wait()

sleep()方法是Thread类里面的，主要的意义就是让当前线程停止执行，让出CPU给其他的线程，但是不会释放对象锁资源以及监控的状态，当指定的时间到了之后又会自动恢复运行状态。

wait()方法是Object类里面的，主要的意义就是让线程放弃当前的对象的锁，进入等待此对象的等待锁定池，只有针对此对象调动notify方法后本线程才能够进入对象锁定池准备获取对象锁进入运行状态。


public class ThreadSleepWait {
	/** java中的sleep()和wait()的区别 */
    public static void main(String[] args) {
        new Thread(new Thread1()).start();
        try {
        	System.out.println("主线程Sleep");
        	Thread.sleep(5000);
         } catch (Exception e) {
            e.printStackTrace();
        }
        new Thread(new Thread2()).start();
    }

    private static class Thread1 implements Runnable{
        @Override
        public void run(){
            synchronized (ThreadSleepWait.class) {
            	System.out.println("启动线程" + Thread.currentThread().getName());    
            	System.out.println("线程等待中...");
	            try {
	            	//调用wait()方法，线程会放弃对象锁，进入等待此对象的等待锁定池
	            	ThreadSleepWait.class.wait();
	             } catch (Exception e) {
	                e.printStackTrace();
	            }
	            System.out.println("线程1继续");
	            System.out.println("线程1结束");
            }
    	}
	}

    private static class Thread2 implements Runnable{
        @Override
        public void run(){
            synchronized (ThreadSleepWait.class) {
            	System.out.println("启动线程" + Thread.currentThread().getName());    
            	System.out.println("线程等待中...");
                //只有针对此锁对象调用notify后
            	//本线程才进入对象锁定池准备获取对象锁进入运行状态。
                ThreadSleepWait.class.notify();
                 
				//区别
				//如果我们把代码：ThreadSleepWait.class.notify给注释掉，
				//ThreadSleepWait.class调用了wait()方法但是没有调用notify()方法,
				//则线程1永远处于挂起状态。
                 
                try {
				//Sleep方法导致了程序暂停执行指定的时间,让出cpu该其他线程，
				//但是他的监控状态依然保持者,当指定的时间过又会自动恢复运行状态。
				//在调用sleep方法的过程中，线程不会释放对象锁。
                     Thread.sleep(5000);
                } catch (Exception e) {
                    e.printStackTrace();
                }
                System.out.println("线程2继续");
	            System.out.println("线程2结束");
            }
        }
    }
}

运行效果：

主线程Sleep
启动线程Thread-0
线程等待中...
启动线程Thread-1
线程等待中...
线程2继续
线程2结束
线程1继续
线程1结束

如果注释掉代码，之后调用

1	ThreadSleepWait.class.notify();

运行效果：

主线程Sleep
启动线程Thread-0
线程等待中...
启动线程Thread-1
线程等待中...
线程2继续
线程2结束

Thread start() 和 run()

2018-04-01

Thread start() 和 run()

start 和 run 方法解释：

1） start：
用start方法来启动线程，真正实现了多线程运行，这时无需等待run方法体代码执行完毕而直接继续执行下面的代码。通过调用Thread类的start()方法来启动一个线程，这时此线程处于就绪（可运行）状态，并没有运行，一旦得到cpu时间片，就开始执行run()方法，这里方法 run()称为线程体，它包含了要执行的这个线程的内容，Run方法运行结束，此线程随即终止。

2） run：
run()方法只是类的一个普通方法而已，如果直接调用Run方法，程序中依然只有主线程这一个线程，其程序执行路径还是只有一条，还是要顺序执行，还是要等待run方法体执行完毕后才可继续执行下面的代码，这样就没有达到写线程的目的。总结：调用start方法方可启动线程，而run方法只是thread的一个普通方法调用，还是在主线程里执行。这两个方法应该都比较熟悉，把需要并行处理的代码放在run()方法中，start()方法启动线程将自动调用 run()方法，这是由jvm的内存机制规定的。并且run()方法必须是public访问权限，返回值类型为void。

Java 的线程是通过java.lang.Thread类来实现的。VM启动时会有一个由主方法所定义的线程。可以通过创建Thread的实例来创建新的线程。每个线程都是通过某个特定Thread对象所对应的方法run（）来完成其操作的，方法run()称为线程体。通过调用Thread类的start()方法来启动一个线程。

在Java 当中，线程通常都有五种状态，创建、就绪、运行、阻塞和死亡。
第一是创建状态。在生成线程对象，并没有调用该对象的start方法，这是线程处于创建状态。
第二是就绪状态。当调用了线程对象的start方法之后，该线程就进入了就绪状态，但是此时线程调度程序还没有把该线程设置为当前线程，此时处于就绪状态。在线程运行之后，从等待或者睡眠中回来之后，也会处于就绪状态。
第三是运行状态。线程调度程序将处于就绪状态的线程设置为当前线程，此时线程就进入了运行状态，开始运行run函数当中的代码。
第四是阻塞状态。线程正在运行的时候，被暂停，通常是为了等待某个时间的发生(比如说某项资源就绪)之后再继续运行。sleep,suspend，wait等方法都可以导致线程阻塞。
第五是死亡状态。如果一个线程的run方法执行结束或者调用stop方法后，该线程就会死亡。对于已经死亡的线程，无法再使用start方法令其进入就绪。

调用start（）后，线程会被放到等待队列，等待CPU调度，并不一定要马上开始执行，只是将这个线程置于可动行状态。然后通过JVM，线程Thread会调用run（）方法，执行本线程的线程体。先调用start后调用run，这么麻烦，为了不直接调用run？就是为了实现多线程的优点，没这个start不行。

1.start（）方法来启动线程，真正实现了多线程运行。这时无需等待run方法体代码执行完毕，可以直接继续执行下面的代码；通过调用Thread类的start()方法来启动一个线程，这时此线程是处于就绪状态，并没有运行。然后通过此Thread类调用方法run()来完成其运行操作的，这里方法run()称为线程体，它包含了要执行的这个线程的内容， Run方法运行结束，此线程终止。然后CPU再调度其它线程。
2.run（）方法当作普通方法的方式调用。程序还是要顺序执行，要等待run方法体执行完毕后，才可继续执行下面的代码；程序中只有主线程——这一个线程，其程序执行路径还是只有一条，这样就没有达到写线程的目的。
记住：多线程就是分时利用CPU，宏观上让所有线程一起执行，也叫并发。

Thread实现多线程一

2018-04-01

Thread实现多线程一

Thread类实现了Runnable接口。

以下是关系到线程运行状态的几个方法：

1）start方法

start()用来启动一个线程，当调用start方法后，系统才会开启一个新的线程来执行用户定义的子任务，在这个过程中，会为相应的线程分配需要的资源。

2）run方法

run()方法是不需要用户来调用的，当通过start方法启动一个线程之后，当线程获得了CPU执行时间，便进入run方法体去执行具体的任务。注意，继承Thread类必须重写run方法，在run方法中定义具体要执行的任务。

3）sleep方法

sleep方法有两个重载版本：

1 2	sleep(long millis) //参数为毫秒 sleep(long millis,int nanoseconds) //第一参数为毫秒，第二个参数为纳秒

sleep相当于让线程睡眠，交出CPU，让CPU去执行其他的任务。

但是有一点要非常注意，sleep方法不会释放锁，也就是说如果当前线程持有对某个对象的锁，则即使调用sleep方法，其他线程也无法访问这个对象。

import java.util.Date;

public class MutipleThread {
	
	private int i = 10;
    private Object object = new Object(); //锁
	     
	
	public class ProcessThread extends Thread{
		@Override
		public void run() {
			System.out.println("开始线程" + new Date());
			//会上锁
			synchronized (object) {
				i++;
				System.out.println("i:" + i);
				try {
				    System.out.println("线程" + Thread.currentThread().getName() + "进入睡眠状态");
				    Thread.currentThread().sleep(10000);
				} catch (InterruptedException e) {
				    // TODO: handle exception
				}
				System.out.println("线程"+Thread.currentThread().getName()+"睡眠结束");
				i++;
				System.out.println("i:" + i);
			}
		}
	}
	
	public static void main(String[] args) {
		// TODO Auto-generated method stub
		MutipleThread mThread = new MutipleThread();
		ProcessThread pThread = mThread.new ProcessThread();
		ProcessThread pThread2 = mThread.new ProcessThread();
		pThread.start();
		pThread2.start();
	}
}

执行结果：

开始线程Thu Jun 27 09:43:40 CST 2019
i:11
线程Thread-0进入睡眠状态
开始线程Thu Jun 27 09:43:40 CST 2019
线程Thread-0睡眠结束
i:12
i:13
线程Thread-1进入睡眠状态
线程Thread-1睡眠结束
i:14

从上面输出结果可以看出，当Thread-0进入睡眠状态之后，Thread-1并没有去执行具体的任务。只有当Thread-0执行完之后，此时Thread-0释放了对象锁，Thread-1才开始执行。

注意，如果调用了sleep方法，必须捕获InterruptedException异常或者将该异常向上层抛出。当线程睡眠时间满后，不一定会立即得到执行，因为此时可能CPU正在执行其他的任务。所以说调用sleep方法相当于让线程进入阻塞状态。

多线程

2018-04-01

多线程

一般来说，线程包括以下这几个状态：创建(new)、就绪(runnable)、运行(running)、阻塞(blocked)、time waiting、waiting、消亡（dead）。

当需要新起一个线程来执行某个子任务时，就创建了一个线程。但是线程创建之后，不会立即进入就绪状态，因为线程的运行需要一些条件，只有线程运行需要的所有条件满足了，才进入就绪状态。

当线程进入就绪状态后，不代表立刻就能获取CPU执行时间，也许此时CPU正在执行其他的事情，因此它要等待。当得到CPU执行时间之后，线程便真正进入运行状态。

线程在运行状态过程中，可能有多个原因导致当前线程不继续运行下去，比如用户主动让线程睡眠（睡眠一定的时间之后再重新执行）、用户主动让线程等待，或者被同步块给阻塞，此时就对应着多个状态：time waiting（睡眠或等待一定的事件）、waiting（等待被唤醒）、blocked（阻塞）。

当由于突然中断或者子任务执行完毕，线程就会被消亡。

Thread实现多线程二

2018-04-01

Thread实现多线程二

接上文，关系到线程运行状态的几个方法：

4）yield方法

调用yield方法会让当前线程交出CPU权限，让CPU去执行其他的线程。它跟sleep方法类似，同样不会释放锁。但是yield不能控制具体的交出CPU的时间，另外，yield方法只能让拥有相同优先级的线程有获取CPU执行时间的机会。

注意，调用yield方法并不会让线程进入阻塞状态，而是让线程重回就绪状态，它只需要等待重新获取CPU执行时间，这一点是和sleep方法不一样的。

5）join方法

join方法有三个重载版本：

1
2
3

join()
join(long millis)     //参数为毫秒
join(long millis,int nanoseconds)    //第一参数为毫秒，第二个参数为纳秒

假如在main线程中，调用thread.join方法，则main方法会等待thread线程执行完毕或者等待一定的时间。如果调用的是无参join方法，则等待thread执行完毕，如果调用的是指定了时间参数的join方法，则等待一定的事件。

import java.io.IOException;

public class ThreadJoin {

	 public static void main(String[] args) throws IOException  {
	        System.out.println("进入线程" + Thread.currentThread().getName());
	        ThreadJoin test = new ThreadJoin();
	        MyThread thread1 = test.new MyThread();
	        //线程开始
	        thread1.start();
	        try {
	            System.out.println("线程 " + Thread.currentThread().getName() + "等待");
	            thread1.join();//使主线程进入等待，其他线程执行完毕
	            System.out.println("线程" + Thread.currentThread().getName() + "继续执行");
	        } catch (InterruptedException e) {
	            // TODO Auto-generated catch block
	            e.printStackTrace();
	        }
    } 
	     
    class MyThread extends Thread{
        @Override
        public void run() {
            System.out.println("进入线程" + Thread.currentThread().getName());
            try {
                Thread.currentThread().sleep(5000);
            } catch (InterruptedException e) {
                // TODO: handle exception
            }
            System.out.println("线程" + Thread.currentThread().getName()+"执行完毕");
        }
    }
}

执行结果：

进入线程main
线程 main等待
进入线程Thread-0
线程Thread-0执行完毕
线程main继续执行

可以看出，当调用thread1.join()方法后，main线程会进入等待，然后等待thread1执行完之后再继续执行。

实际上调用join方法是调用了Object的wait方法。

Runnable接口程实现多线程

2018-04-01

Runnable接口程实现多线程

写一个类实现Runnable接口，实现run方法。用new Thread(Runnableclass).start()方法来启动

public class RunnableTask {
	
    public static void main(String[] args) {  
    	RunnableTask rt = new RunnableTask();
        Runner1 runner1 = rt.new Runner1();  
        Runner2 runner2 = rt.new Runner2();  
          
        Thread thread1 = new Thread(runner1);  
        Thread thread2 = new Thread(runner2);  
	    thread1.start();  
	    thread2.start();  
        //thread1.run();  
        //thread2.run();  
    }  
	 
	  
	class Runner1 implements Runnable { 
		// 实现了Runnable接口，jdk就知道这个类是一个线程  
	    public void run() {  
	        for (int i = 0; i < 100; i++) {  
	            System.out.println("进入Runner1运行状态——————————" + i);  
	        }  
	    }  
	}  
	  
	class Runner2 implements Runnable { 
		// 实现了Runnable接口，jdk就知道这个类是一个线程  
	    public void run() {  
	        for (int i = 0; i < 100; i++) {  
	            System.out.println("进入Runner2运行状态==========" + i);  
	        }  
	    }  
	}
}

Java 多线程上下文切换

2018-04-01

多线程上下文切换

对于单核CPU来说（对于多核CPU，此处就理解为一个核），CPU在一个时刻只能运行一个线程，当在运行一个线程的过程中转去运行另外一个线程，这个叫做线程上下文切换（对于进程也是类似）。

由于可能当前线程的任务并没有执行完毕，所以在切换时需要保存线程的运行状态，以便下次重新切换回来时能够继续切换之前的状态运行。举个简单的例子：比如一个线程A正在读取一个文件的内容，正读到文件的一半，此时需要暂停线程A，转去执行线程B，当再次切换回来执行线程A的时候，我们不希望线程A又从文件的开头来读取。

因此需要记录线程A的运行状态，那么会记录哪些数据呢？因为下次恢复时需要知道在这之前当前线程已经执行到哪条指令了，所以需要记录程序计数器的值，另外比如说线程正在进行某个计算的时候被挂起了，那么下次继续执行的时候需要知道之前挂起时变量的值时多少，因此需要记录CPU寄存器的状态。所以一般来说，线程上下文切换过程中会记录程序计数器、CPU寄存器状态等数据。

说简单点的：对于线程的上下文切换实际上就是存储和恢复CPU状态的过程，它使得线程执行能够从中断点恢复执行。

虽然多线程可以使得任务执行的效率得到提升，但是由于在线程切换时同样会带来一定的开销代价，并且多个线程会导致系统资源占用的增加，所以在进行多线程编程时要注意这些因素。

乐观锁常见的两种实现方式

2018-03-25

#乐观锁常见的两种实现方式

乐观锁一般会使用版本号机制或CAS算法实现。

版本号机制

一般是在数据表中加上一个数据版本号version字段，表示数据被修改的次数，当数据被修改时，version值会加一。
当线程A要更新数据值时，在读取数据的同时也会读取version值，在提交更新时，若刚才读取到的version值为当前数据库中的version值相等时才更新，否则重试更新操作，直到更新成功。

举一个简单的例子：

假设数据库中帐户信息表中有一个 version 字段，当前值为 1 ；而当前帐户余额字段（ balance ）为 $100 。

操作员 A 此时将其读出（ version = 1 ），并从其帐户余额中扣除 $50（ $100 - $50 ）。
在操作员 A 操作的过程中，操作员B 也读入此用户信息（ version = 1 ），并从其帐户余额中扣除 $20 （ $100 - $20 ）。
操作员 A 完成了修改工作，将数据版本号加一（ version = 2 ），连同帐户扣除后余额（ balance = $50 ），提交至数据库更新，
此时由于提交数据版本大于数据库记录当前版本，数据被更新，数据库记录 version 更新为 2 。
操作员 B 完成了操作，也将版本号加一（ version = 2 ）试图向数据库提交数据（ balance = $80 ），但此时比对数据库记录版本时发现，操作员 B 提交的数据版本号为 2 ，数据库记录当前版本也为 2 ，
不满足 “ 提交版本必须大于记录当前版本才能执行更新 “ 的乐观锁策略，因此，操作员 B 的提交被驳回。

CAS算法

即compare and swap（比较与交换），是一种有名的无锁算法。
无锁编程，即不使用锁的情况下实现多线程之间的变量同步，也就是在没有线程被阻塞的情况下实现变量的同步，所以也叫非阻塞同步（Non-blocking Synchronization）。
CAS算法涉及到三个操作数：

需要读写的内存值 V
进行比较的值 A
拟写入的新值 B

三个参数，一个当前内存值V、旧的预期值A、即将更新的值B，当且仅当预期值A和内存值V相同时，将内存值修改为B并返回true，否则什么都不做，并返回false。

悲观锁和乐观锁

2018-03-24

悲观锁和乐观锁

何谓悲观锁与乐观锁

乐观锁对应于生活中乐观的人总是想着事情往好的方向发展，
悲观锁对应于生活中悲观的人总是想着事情往坏的方向发展。

悲观锁

总是假设最坏的情况，每次去拿数据的时候都认为别人会修改，所以每次在拿数据的时候都会上锁，这样别人想拿这个数据就会阻塞直到它拿到锁
（共享资源每次只给一个线程使用，其它线程阻塞，用完后再把资源转让给其它线程）。

传统数据库中就有这些机制：比如行锁，表锁等，读锁，写锁等；

Java中synchronized和ReentrantLock等独占锁就是悲观锁思想的实现。

乐观锁

总是假设最好的情况，每次去拿数据的时候都认为别人不会修改，所以不会上锁，但是在更新的时候会判断一下在此期间别人有没有去更新这个数据，可以使用版本号机制和CAS算法实现。

乐观锁适用于多读的应用类型，这样可以提高吞吐量

在Java中java.util.concurrent.atomic包下面的原子变量类就是使用了乐观锁的一种实现方式CAS实现的。

两种锁的使用场景

像乐观锁适用于写比较少的情况下（多读场景），即冲突真的很少发生的时候，这样可以省去了锁的开销，加大了系统的整个吞吐量。
但如果是多写的情况，一般会经常产生冲突，这就会导致上层应用会不断的进行retry，这样反倒是降低了性能，所以一般多写的场景下用悲观锁就比较合适。

Linux常用命令

2018-03-06

Linux常用命令

#Linux 常用命令

cd

==cd /== 进入主目录
==cd ~== 进入Home目录
==cd -== 进入上一次工作中路径

ls

==ls -a== 列出所有
==ls -r== 反序排列
==ls -t== 以文件修改时间排列
==ls -l== 将文件名,文件所有者，文件大小信息详细信息列出来

pwd

mkdir

创建文件夹
可用选项：

==mkdir -m==: 对新建目录设置存取权限,也可以用chmod命令设置;
==mkdir -p==: 可以是一个路径名称。此时若路径中的某些目录尚不存在,加上此选项后,系统将自动建立那些尚不在的目录,即一次可以建立多个目录;

rm

删除文件，删除一个目录中的一个或多个文件或目录，如果没有使用- r选项，则rm不会删除目录

rmdir

从一个目录中删除一个或多个子目录项，删除某目录时也必须具有对其父目录的写权限。

mv

移动文件或修改文件名，根据第二参数类型（如目录，则移动文件；如为文件则重命令该文件）。

cp

将源文件复制至目标文件，或将多个源文件复制至目标目录。

free

显示系统内存使用情况，包括物理内存、交互区内存(swap)和内核缓冲区内存

-b 以Byte显示内存使用情况
-k 以kb为单位显示内存使用情况
-m 以mb为单位显示内存使用情况
-g 以gb为单位显示内存使用情况
-s <间隔秒数> 持续显示内存
-t 显示内存使用总合

cat

cat主要有三大功能：

一次显示整个文件:cat filename
从键盘创建一个文件:cat > filename 只能创建新文件,不能编辑已有文件.
将几个文件合并为一个文件:cat file1 file2 > file

-b对非空输出行号
-n输出所有行号