java 线程操作

一、线程初始化

两种方法：

1.将类声明为Thread类的子类，重写Thead的run方法

 class PrimeThread extends Thread {
         long minPrime;
         PrimeThread(long minPrime) {
             this.minPrime = minPrime;
         }
 
         public void run() {
             // compute primes larger than minPrime
              . . .
         }
     }

启动线程：

PrimeThread p = new PrimeThread(143);
p.start();

2.声明一个实现Runnable接口的类，实现run方法

class PrimeRun implements Runnable {
         long minPrime;
         PrimeRun(long minPrime) {
             this.minPrime = minPrime;
         }
 
         public void run() {
             // compute primes larger than minPrime
              . . .
         }
     }

启动线程：

PrimeRun p = new PrimeRun(143);
new Thread(p).start();

二、多线程操作，为了实现互斥，最常使用的技术是同步，即 <span style="font-size:18px;">synchronized</span>

多个线程只有在对同一个内存对象进行操作时才会出现资源抢占问题，除此之外没必要使用同步，就比如都想在某个时间上一个厕所，就会存在相互打架的情况。

另外在java中synchronized对基本类型如int，char、byte无法加锁。

public class MyThreadTwo implements Runnable{
	Integer number;
	MyThreadTwo(int number){
		//this.data = data;
		this.number = number;
	}

	@Override
	public void run() {
		// TODO Auto-generated method stub
		
		for(int i = 0; i < 1000; i++){
		    System.out.println(i);
		}
	}
	
	 public static void main(String[] args) throws Exception {   
		 //必须是多个线程共享资源，同步才有意义
		 Integer m = 40;
                 for (int i = 1; i < 10; i++) {     
        	     new Thread(new MyThreadTwo(m)).start();     
                     Thread.sleep(1);     
                 }     
          }  
}

预计的顺序输出结果出现这种情况

......

995
996
997
998
999
741
742
743
744

......

解决办法1：给for循环进行同步操作，即对代码块进行加锁

    public void run() {

	synchronized (number) {
		for(int i = 0; i < 1000; i++){
			System.out.println(i);
		}
	}
    }

解决办法2：对方法加synchronized关键字

    public void run() {
	syMethod();
    }
    public synchronized void syMethod(){
	for(int i = 0; i < 1000; i++){
	    System.out.println(i);
	}
    }