多线程，多线程的安全性，锁，线程的同步

 

1线程的基本知识

线程在jdk里有Thread类来描述，程序能够经过继承Thread类来实现多线程，也能够经过实现Thread类子类的Runnable接口来实现多线程。

（1）继承Thread类来实现多线程：继承Thread类，而后重写run方法，再经过建立对象可直接调用start方法，达到启动线程的目的。用这种方法完成双线程需求，它的线程和对象和线程任务同时实现，耦合性过高。此种方式的代码体现;

class Text extends Thread{

public void run(){

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

System.out.println(i);

}

}

}

public class Demo123 {

public static void main(String[] args) {

Text t1=new Text();

Text t2=new Text();

t1.start();

t2.start();

}

}

（2）实现Runnable接口实现多线程：

Runnable是Thread的一个子类，它的子类中只有一个run方法，经过重写run方法，再经过建立Thread对象来建立线程对象，将原类的对象做为参数传给Thread类的构造函数，此原类的对象就是线程任务，接下来调用start来启动线程。此类方式将线程对象和线程任务分开，耦合性低。

代码实例：

class Text implements Runnable{

public void run(){

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

System.out.println(i);

}

}

}

public class Demo123 {

public static void main(String[] args) {

Text t=new Text();

Thread t1=new Thread(t);

Thread t2=new Thread(t);

t1.start();

t2.start();

}

}

2.线程中的异常：

线程中的异常一旦出现，jvm就会报出该线程的异常，main命名的为主函数的异常，其余就是Thread0，Thread1这样依次类推。

3.线程的强化

在线程中可经过sleep（time），wait（可加time可不加），中止的线程可经过noteify来唤醒线程。

4.线程的安全性。

这是线程中很是重要的部分，线程在运行过程当中有三种状态：

执行状态：cpu有执行资格，有执行权

封闭状态 cpu没有执行资格，没执行权

堵塞状态 cpu有执行资格，没执行权

多线程中的安全问题就是因为第三中的堵塞状态引发的，这样的安全性问题在代码运行时每每显而易见的，咱们能够经过synchronized（）线程同步来解决安全问题。

Synchronized的代码体现有二种：一种是同步代码块，一种直接同步方法、

同步代码快的代码实例：

class Text implements Runnable{

Object obj=new Object();

public void run(){

synchronized(obj){

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

System.out.println(i);

}

}

}

}

同步方法的代码实例：

class Text implements Runnable{

Object obj=new Object();

public synchronized void run(){

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

System.out.println(i);

}

}

}

public class Demo123 {

public static void main(String[] args) {

Text t=new Text();

Thread t1=new Thread(t);

Thread t2=new Thread(t);

t1.start();

t2.start();

}

}

这里编辑一下：同步不能直接做用在run方法上，当方法run被同步上锁，那么就变成了单线程，而不是双线程了。

5 锁

在线程同步中，须要用到一个工具---锁。

锁在代码中的体现为：

Synchronized(obj){

}

Obj就是锁，锁能够为任意的对象，在同一个多线程中，要保证线程的安全性，锁必须是同一个。在同步代码快中，锁能够是任意一个对象。在同步函数中，同样存在锁，锁为this.

这咱们能够用两个线程来验证，一个线程用同步方法，一个用同步代码块，同步代码块的锁名称定位this.&#160; 线程的安全性能够获得解决。若是同步方法是个静态方法，由于静态方法不须要this.来访问，随着类的加载而加载。因此它的锁为类的class文件。

对于锁，能够这么总结：多线程中安全性出现了问题，那么就先去查看锁是否为同一个锁。

6懒汉式单例模式中的并发问题

先看代码实例：

class Single {

static Object obj=new Object();

private static Single s=null;

private Single(){}

public static Single getIntance(){

if(s==null){

synchronized(obj){

if(s==null){

s=new Single();

}

}

}

return s;

}

}

public class Demo123 implements Runnable {

public void run(){

Single.getIntance();

}

}

代码分析：同步synchronized来解决线程的安全性问题，用两次判断来解决同步带来的效率低的问题。