网络与线程

一：线程

  1：建立Runnable对象（线程任务）

　　　　Runnable threadJob  = new MyRunnable();

　　　　class MyRunnable implements Runnable{

　　　　}

　2：建立Thread对象（执行工人）并赋值Runnable（任务）

　　　　Thread myThread = new Thread(threadJob);

　　　　把Runnable对象传给Thread的构造函数。这会告诉Thread对象要把哪个方法放在要执行的空间去运行--Runnable的run()方法。

   3：启动Thread

　　       myThread.start();

　　　　在还没有调用Thread的start()方法之前什么也不会发生，这是你在只有一个Thread实例来建立新的线程时会发生的事情。当新线程启动之后，他会把Runnable对象的方法摆到新的执行空间中。

 

二：多线程并发

　　并发性问题会引发竞争状态。竞争状态会引发数据的损毁。

     示例：

　　　　

public class Demo implements Runnable{
　　private BankAccount account = new BankAccount();

　　public static void main(String[] args){
　　　　Demo d = new Demo();
　　　　Thread one = new Thread(d);
　　　　Thread two = new Thread(d);

　　　　one.setName("T1");
　　　　two.setName("T2");

　　　　one.start();
　　　　two.start();

　　}

　　public void run(){
　　　　for(int x =0;x<10;x++){
　　　　　　makeWithdrawl(10);
　　　　　　if(account.getBalance()<0){
　　　　　　　　System.out.println("Overdraw!");
　　　　　　}
　　　　}
　　}

　　private void makeWithdrawl(int amount){
　　　　if(account.getBalance()>=amount){
　　　　　　System.out.println(Thread.currentThread().getName()+"is about to withdraw");
　　　　　　try{
　　　　　　　　System.out.println(Thread.currentThread().getName()+"is going to sleep");
　　　　　　}catch(Exception e){
　　　　　　　　e.printStackTrace();
　　　　　　}
　　　　　　System.out.println(Thread.currentThread().getName()+"woke up");
　　　　　　account.withdraw(amount);
　　　　　　System.out.println(Thread.currentThread().getName()+"completes the withdrawl");
　　　　}
　　　　else{
　　　　　　System.out.println("Sorry,not enough for "+Thread.currentThread().getName());
　　　　}
　　}
}

class BankAccount{
　　private int balance = 100;

　　public int getBalance(){
　　　　return balance;
　　}

　　public void withdraw(int amount){
　　　　balance = balance - amount;

　　　　System.out.println(balance);
　　}
}

三：锁

　　　synchronized关键字代表线程需要一把钥匙来存取被同步化（synchronized）过的线程。要保护数据，就把作用在数据上的方法给同步化。

　　　public synchronized void makeWithdrawal(int amount){}

　　　对象锁：

　　　　　　每个对象都有锁，大部分时间都没有锁上。对象的锁只会在同步化的方法上起作用，如果对象有两个同步化的方法，就表示两个线程无法进入同一方法，也表示两个线程无法进入不同的方法。

　　　　　　

　　　　　　原则上：最好只做最少量的同步化。事实上同步的规模可以小于方法全部。你可以用synchronized 来修饰一行或多行的指令而不必整个方法都同步化。

 　　　　　　public void go(){

　　　　　　　　doStuff();

　　　　　　　　synchronized(this){

　　　　　　　　　　//code

　　　　　　　　}

　　　　　　}