java多线程入门例子-第一例

• – 认识多线程-1

public class First extends Thread{
//写一个类执行十次随机时间休眠
    @Override
    public void run() {
    try {
        for(int i=0;i<10;i++)
        {
            int time =(int)(Math.random()*1000);
            Thread.sleep(time);
            System.out.println("当前线程是  "+Thread.currentThread().getName()); 
        }
        }
        catch (InterruptedException e) {
                e.printStackTrace();
        }
    }
}

public class App {
    public static void main(String[] args) {
        try {
            First thread = new First();
            thread.setName("new Thread");
            thread.start();
            for(int i=0;i<10;i++)
            {
                int time = (int)(Math.random()*1000);
                Thread.sleep(time);
                System.out.println("当前线程是  "+Thread.currentThread().getName());
            } 
        }
        catch (InterruptedException e) {
            e.printStackTrace();
        }
    }
}

结果如下
当前线程是 new Thread
当前线程是 main
当前线程是 new Thread
当前线程是 main
当前线程是 main
当前线程是 new Thread
当前线程是 main
当前线程是 new Thread
当前线程是 main
当前线程是 main
当前线程是 new Thread
当前线程是 new Thread
当前线程是 new Thread
当前线程是 main
当前线程是 new Thread
当前线程是 main
当前线程是 main
当前线程是 main
当前线程是 new Thread
当前线程是 new Thread
由此结果可以看出两个之间的执行顺序是随机的互相抢占式的，线程具有随机执行的特点

- 认识多线程-2

public class Second extends Thread{
    private int i;
    public Second(int i) {
        super();
        this.i=i;
    }
    @Override
    public void run() {
        System.out.println(i);
    }
}
public class App {
    public static void main(String[] args) {
        Second s1 = new Second(1);
        Second s2 = new Second(2);
        Second s3 = new Second(3);
        Second s4 = new Second(4);
        Second s5 = new Second(5);
        Second s6 = new Second(6);
        Second s7 = new Second(7);

        s1.start();
        s2.start();
        s3.start();
        s4.start();
        s5.start();
        s6.start();
        s7.start();


    }

}

结果如下：
1
6
4
3
2
7
5
通过例子2可以看出来执行start方法的顺序不代表线程启动的顺序

• 第二例 – 数据共享问题
  数据不共享举例

public class MyThread extends Thread{
    private int i= 4;
    @Override
    public void run() {
        i--;
        System.out.println("线程： "+Thread.currentThread().getName()+" 计算 i= "+i);
    }
}

public class App {
public static void main(String[] args) {
    MyThread t1 = new MyThread("线程1");
    MyThread t2 = new MyThread("线程2");
    MyThread t3 = new MyThread("线程3");
    t1.start();
    t2.start();
    t3.start();
}
}

运行结果
线程： 线程3 计算 i= 2
线程： 线程2 计算 i= 2
线程： 线程1 计算 i= 2
线程： 线程2 计算 i= 1
线程： 线程3 计算 i= 1
线程： 线程2 计算 i= 0
线程： 线程1 计算 i= 1
线程： 线程1 计算 i= 0
线程： 线程3 计算 i= 0
由上可见此实例是正常的实例，不存在多个线程同时访问同一个资源的情况

public class MyThread extends Thread{
    private int i= 4;
    @Override
    public void run() {
        i--;
        System.out.println("线程： "+Thread.currentThread().getName()+" 计算 i= "+i);
    }
}
public class App {
public static void main(String[] args) {
    MyThread myThread = new MyThread();
    Thread t1= new Thread(myThread,"线程1");
    Thread t2= new Thread(myThread,"线程2");
    Thread t3= new Thread(myThread,"线程3");
    Thread t4= new Thread(myThread,"线程4");
    Thread t5= new Thread(myThread,"线程5");

    t1.start();
    t2.start();
    t3.start();
    t4.start();
    t5.start();
}
}

结果如下：
线程： 线程1 计算 i= 3
线程： 线程3 计算 i= 1
线程： 线程2 计算 i= 1
线程： 线程5 计算 i= -1
线程： 线程4 计算 i= 0
由上可见，几个线程同时访问出现了 数据安全问题，打印结果是重复的，而不是递减的

public class MyThread extends Thread{
    private int i= 4;
    @Override
    synchronized public void run() {
        i--;
        System.out.println("线程： "+Thread.currentThread().getName()+" 计算 i= "+i);
    }
}

加上这个synchronized 线程同步锁就可以正常输出结果了，这个方法让线程之间以排队的方式去执行任务调度，当一个线程想去调用方法时，先去看有没有锁，。