Java传统线程创建方式和互斥

 * 多线程并不会提高执行效率，性能更低

 * 多线程会抢占cpu的资源，会占用更多的服务器带宽，这样看起来就感觉会更快

创建线程有两种方式：一种是创建Thread的子类，覆盖Thread的run方法，还有一种是构造器传入Runnable对象，使用Runnable对象的run方法：

public class TraditionlThread {

/**
* 创建线程的两种方式
* @param args
*/
public static void main(String[] args) {
//方式一： 创建Thread的子类，覆盖Thread的run方法
Thread thread = new Thread(){
@Override
public void run() {
while(true){
try {
Thread.sleep(500);
} catch (Exception e) {
e.printStackTrace();
}
System.out.println(Thread.currentThread().getName());
}
}
};
thread.start();

// 源码里边是Runnable对象不为null就执行Runnable的run方法
// 方式二：构造函数中传入Runnable对象
Thread thread2 = new Thread(new Runnable() {
@Override
public void run() {
while(true){
try {
Thread.sleep(500);
} catch (Exception e) {
e.printStackTrace();
}
System.out.println(Thread.currentThread().getName());
}
}
});
thread2.start();

/*
* 两种方式的区别：
* 第二种方式更加体现面向对象的方式
*
* */

// 同时有子类的run方法和Runnable对象，那么程序会执行子类的run方法，子类的方法会覆盖父类的
new Thread(new Runnable() {

@Override
public void run() {
while(true){
try {
Thread.sleep(500);
} catch (Exception e) {
e.printStackTrace();
}
System.out.println("runnable Thread:" + Thread.currentThread().getName());
}

}
}){
public void run() {
while(true){
try {
Thread.sleep(500);
} catch (Exception e) {
e.printStackTrace();
}
System.out.println("子类 Thread:" + Thread.currentThread().getName());
}
};
}.start();

}
}

线程的互斥：使用sychronized关键字

/**
* 傳統線程互斥技術
* 線程安全問題可以用銀行轉賬來解釋
* @author admin
*/
public class TraditionalSychronized{

public static void main(String[] args) {
OutputSafe2 out = new OutputSafe2();
write(out);
}

/**
* 這樣寫會出現錯亂
*/
static class Output{
public void output(String name){
for(int i=0; i<name.length(); i++){
System.out.print(name.charAt(i));
}
System.out.println();
}
}

/**
* 方式一： 同步代碼塊
* 調用此方法的鎖要為同一個對象
*/
static class OutputSafe1{
public void output(String name){
synchronized(OutputSafe1.class){ // 鎖對象可以設置為當前類的字節碼對象
for(int i=0; i<name.length(); i++){
System.out.print(name.charAt(i));
}
System.out.println();
}
}
}

/**
* 方式二：同步方法
* 方法裡邊的所有代碼都需要原子性 那麼用同步方法
*
*  注意：如果給同步方法中寫同步代碼塊很容易發生死鎖現象
*/
static class OutputSafe2{
public synchronized void output(String name){
for(int i=0; i<name.length(); i++){
System.out.print(name.charAt(i));
}
System.out.println();
}
}

public static void write(OutputSafe2 out){
new Thread(new Runnable() {
public void run() {
while(true){
try {
Thread.sleep(10);
} catch (Exception e) {
e.printStackTrace();
}
out.output("abcdef");
}
}
}).start();

new Thread(new Runnable() {
public void run() {
while(true){
try {
Thread.sleep(10);
} catch (Exception e) {
e.printStackTrace();
}
out.output("uvwxyz");
}
}
}).start();
}

}

线程同步通信的例子：

main本身就是是一个线程

/**
* 题目：子线程循环10次，接着主线程循环5次，接着又回到子线程循环10次，主线程循环100次，
* 如此循环50次
*
*/
public class Test {

public static void main(String[] args) {
Business business = new Business();
new Thread(new Runnable() {
@Override
public void run() {
for(int i=0; i<50; i++){
business.sub(i);
}
}
}).start();

for(int i= 0 ; i< 50 ; i++){
business.main(i);
}
}

static class Business{
boolean shouldSub = true;
public synchronized void sub(int i){
while(!shouldSub){ //使用while而不是if防止偽喚醒
try {
this.wait();
} catch (InterruptedException e) {
e.printStackTrace();
}
}
for(int j=0; j<10; j++){
System.out.println("thread1 : " + j + "/" + i);
}
shouldSub = false;
this.notify();
}

public synchronized void main(int i){
while(shouldSub){
try {
this.wait();
} catch (InterruptedException e) {
e.printStackTrace();
}
}
for(int j=0; j<5; j++){
System.out.println("thread2 : " + j + "/"+ i);
}
shouldSub = true;
this.notify();
}
}
}