Java知识(多线程模式和线程安全)

1.多线程模式

方式1：

/**

* 多线程

* 实现方式1：自定义一个类继承Thread类，并重写run方法

* @author admin

*

*/

public class Ch03 {

/**

* 系统默认情况下只运行主线程

* @param args

* @throws InterruptedException

*/

public static void main(String[] args) throws InterruptedException {

//主线程

//在主线程中开启两个子线程

// Thred1 thred1=new Thred1();

// Thred2 thred2=new Thred2();

// thred1.start();

// thred2.start();

System.out.println("倒计时3");

Thread.sleep(1000);

System.out.println("倒计时2");

Thread.sleep(1000);

System.out.println("倒计时1");

}

}

/**

* 多线程类1

* @author admin

*

*/

class Thred1 extends Thread{

/**

* 线程运行期间运行的代码

*/

@Override

public void run() {

// TODO Auto-generated method stub

System.out.println("线程1开始运行...");

//Thred.sleep方法 使线程休眠以毫秒为单位

try {

//休眠1秒钟

Thread.sleep(3000);

} catch (InterruptedException e) {

// TODO Auto-generated catch block

e.printStackTrace();

}

System.out.println("线程1继续运行...");

}

}

/**

* 多线程类2

* @author admin

*

*/

class Thred2 extends Thread{

/**

* 线程运行期间运行的代码

*/

@Override

public void run() {

// TODO Auto-generated method stub

System.out.println("线程2开始运行...");

//Thred.sleep方法 使线程休眠以毫秒为单位

try {

//休眠1秒钟

Thread.sleep(3000);

} catch (InterruptedException e) {

// TODO Auto-generated catch block

e.printStackTrace();

}

System.out.println("线程2继续运行...");

}

}

方式2：

public static void main(String[] args) {

//多线程操作

//2.直接使用Thred类操作

//利用匿名类直接创建对象

Thread thread1=new Thread(){

@Override

public void run() {

// TODO Auto-generated method stub

//

try {

Thread.sleep(3000);

} catch (InterruptedException e) {

// TODO Auto-generated catch block

e.printStackTrace();

}

Singleton singleton=Singleton.getInstance();

System.out.println(singleton.hashCode());

}

};

//开启新线程

thread1.start();

}

Thred.sleep方法 使线程休眠以毫秒为单位

2.线程安全

饿汉模式本身就是线程安全的，可以直接用于多线程而不会出现问题

懒汉式是非线程安全的，解决方式如下：

1.关键字：synchronized：可用来给对象和方法或者代码块加锁，当它锁定一个方法或者一个代码块的时候，同一时刻最多只有一个线程执行这段代码。缺点：效率低

public static synchronized Singleton getInstance(){

//判断全局对象是否为空

if (singleton==null) {

//休眠1秒

//如果为空，就创建对象

singleton=new Singleton();

System.out.println("创建新对象");

}

//如果不为空，则直接返回该对象

return singleton;

}

2.用双重检测机制实现线程安全的懒汉模式

public static Singleton getInstance(){

//判断全局对象是否为空

if (singleton==null) {

//休眠1秒

//如果为空，就创建对象

synchronized (Singleton.class) {

singleton=new Singleton();

System.out.println("创建新对象");

}

}

//如果不为空，则直接返回该对象

return singleton;

}

3.使用静态内部类实现线程安全的单例模式

public class Singleton {

private Singleton(){

}

//内部类

private static class Singleton{

private static Singleton instance=new Singleton();

}

public static Singleton getInstance(){

return Singleton.instance;

}

}

static修饰内部类的时候，不会被提前加载，只有当被调用时才会加载；static修饰其他内容时，只要类被加载后就会执行static代码；static关键字修饰的内容，只用加载一遍。