JAVA多线程扫盲

1.继承Thread类，重写该类的run()方法。

class MyThread extends Thread {

    private int i = 0;

    @Override

    public void run() {

        for (i = 0; i < 100; i++) {

            System.out.println(Thread.currentThread().getName() + " " + i);

        }

    }

}

 

public class ThreadTest {

    public static void main(String[] args) {

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

            System.out.println(Thread.currentThread().getName() + " " + i);

            if (i == 30) {

                Thread myThread1 = new MyThread();

                Thread myThread2 = new MyThread(); 

                myThread1.start(); 

                myThread2.start();

            }

        }

    }

}

2.实现Runnable接口，并重写该接口的run()方法

class MyRunnable implements Runnable {

    private int i = 0;

    @Override

    public void run() {

        for (i = 0; i < 100; i++) {

            System.out.println(Thread.currentThread().getName() + " " + i);

        }

    }

}

 

public class ThreadTest {

    public static void main(String[] args) {

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

            System.out.println(Thread.currentThread().getName() + " " + i);

            if (i == 30) {

                Runnable myRunnable = new MyRunnable(); 

                Thread thread1 = new Thread(myRunnable); 

                Thread thread2 = new Thread(myRunnable);

                thread1.start(); 

                thread2.start();

            }

        }

    }

}

 

3.比较简洁的写法

  new Thread(new Runnable() {

   @Override

     public void run() {

           //具体实现

      }

   }).start();

这种写法是利用了匿名内部类

同等这种写法，实例化了一个Runnable接口子类的实例
Thread t=new Thread(new MyRunnable());
public class MyRunnable implements Runnable{
@Override
public void run() {
  //具体实现
}
}

t.start();

 

4.使用Callable和Future接口创建线程

public class ThreadTest {

    public static void main(String[] args) {

        Callable<Integer> myCallable = new MyCallable();    

        FutureTask<Integer> ft = new FutureTask<Integer>(myCallable); 

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

            System.out.println(Thread.currentThread().getName() + " " + i);

            if (i == 30) {

                Thread thread = new Thread(ft); 

                thread.start(); 

            }

        }

        System.out.println("主线程for循环执行完毕..");

        try {

            int sum = ft.get(); 

            System.out.println("sum = " + sum);

        } catch (InterruptedException e) {

            e.printStackTrace();

        } catch (ExecutionException e) {

            e.printStackTrace();

        }

    }

}

 

class MyCallable implements Callable<Integer> {

    private int i = 0;

    // 与run()方法不同的是，call()方法具有返回值

    @Override

    public Integer call() {

        int sum = 0;

        for (; i < 100; i++) {

            System.out.println(Thread.currentThread().getName() + " " + i);

            sum += i;

        }

        return sum;

    }

 

}

 

以下是生产者消费者模式

public class ProducerConsumer {

 

public static void main(String[] args) {

SyncStack ss = new SyncStack();

Producer pp = new Producer(ss);

Consumer cc = new Consumer(ss);

new Thread(pp).start();

new Thread(cc).start();

 

}

}

 

class WoTou {

int id;

WoTou(int id) {

this.id = id;

}

public String toString() {

return "WoTou id:" + id;

}

}

 

class SyncStack {

int index = 0;

WoTou[] arrWt = new WoTou[6];

public synchronized void push(WoTou wt) {

while (index == arrWt.length) {

try {

this.wait();

} catch (InterruptedException e) {

e.printStackTrace();

}

}

// 叫醒一个现在正在wait该对象上的线程

this.notify();

arrWt[index] = wt;

index++;

}

 

public synchronized WoTou pop() {

while (index == 0) {

try {

this.wait();

} catch (InterruptedException e) {

e.printStackTrace();

}

}

this.notify();

index--;

return arrWt[index];

}

}

 

// 生产

class Producer implements Runnable {

SyncStack ss = null;

Producer(SyncStack ss) {

this.ss = ss;

}

 

public void run() {

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

WoTou wt = new WoTou(i);

ss.push(wt);

System.out.println("生产了:" + wt);

try {

Thread.sleep((int) Math.random() * 2);

} catch (InterruptedException e) {

e.printStackTrace();

}

}

}

}

 

// 消费

class Consumer implements Runnable {

SyncStack ss = null;

Consumer(SyncStack ss) {

this.ss = ss;

}

 

public void run() {

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

WoTou wt = ss.pop();

System.out.println("消费了:" + wt);

try {

Thread.sleep((int) Math.random() * 1000);

} catch (InterruptedException e) {

e.printStackTrace();

}

}

}

}

sleep()使线程睡过去,也就是暂停执行,或者让出cpu给别的线程使用..

wait()是线程等待事件的发生,如果你的线程需要某个条件才能继续运行,就用wait(),他不占资源，只是不运行线程而已　等待命令的意思

notify()通知相应的在等待的线程条件已经满足,可以启动了,采用wait()的线程只能够通过notify或者是notifyAll()启动,不能够自己启动的.
// sleep 时别的线程不可以访问锁定对象