Java多线程

Java多线程

创建线程的两种方式

/*
进程：是一个正在执行中的程序。
	 每一个进程执行都有一个执行顺序。该顺序是一个执行路径，或者叫一个控制单元。
线程：就是进程中的一个独立的控制单元。
	 线程在控制着进程的执行。

一个进程中至少有一个线程。

Java VM  启动的时候会有一个进程java.exe.
该进程中至少一个线程负责java程序的执行。
而且这个线程运行的代码存在于main方法中。
该线程称之为主线程。
其实更细节说明jvm，jvm启动不止一个线程，还有负责垃圾回收机制的线程。

创建线程的第一种方式：继承Thread类。
步骤：
1，定义类继承Thread。
2，复写Thread类中的run方法。将自定义代码存储在run方法。让线程运行。
3，调用线程的start方法，该方法两个作用：启动线程，调用run方法。



*/

class Demo extends Thread {
    public void run() {
        for (int x = 0; x < 60; x++)
            System.out.println("demo run----" + x);
    }
}

class Test extends Thread {
    //private String name;
    Test(String name) {
        //this.name = name;
        super(name);
    }

    public void run() {
        for (int x = 0; x < 60; x++) {
            System.out.println((Thread.currentThread() == this) + "..." + this.getName() + " run..." + x);
        }
    }

}

class ThreadDemo {
    public static void main(String[] args) {
        //for(int x=0; x<4000; x++)
        //System.out.println("Hello World!");

        Demo d = new Demo();//创建好一个线程。
        d.start();//开启线程并执行该线程的run方法。
        //d.run();//仅仅是对象调用方法。而线程创建了，并没有运行。

        for (int x = 0; x < 60; x++)
            System.out.println("Hello World!--" + x);

		Test t1 = new Test("one——");
		Test t2 = new Test("two——");
    }
}

/*

创建线程的第二种方式：实现Runable接口

步骤：
1，定义类实现Runnable接口
2，覆盖Runnable接口中的run方法。将线程要运行的代码存放在该run方法中。
3，通过Thread类建立线程对象。
4，将Runnable接口的子类对象作为实际参数传递给Thread类的构造函数。
5，调用Thread类的start方法开启线程并调用Runnable接口子类的run方法。

线程安全问题：
synchronized(对象)
{
	需要被同步的代码
}
对象如同锁。持有锁的线程可以在同步中执行。
没有持有锁的线程即使获取cpu的执行权，也进不去，因为没有获取锁。

*/

class Ticket implements Runnable {
    private int tick = 20;
	Object obj = new Object();
    public void run() {
        while (true) {
        	synchronized(obj) {//可以直接用synchronized(this) 这样就解决了线程安全问题
           	    if (tick > 0) {
                System.out.println(Thread.currentThread().getName() + "....sale : " + tick--);
            	}
            }
        }
    }
}


class TicketDemo {
    public static void main(String[] args) {

        Ticket t = new Ticket();

        Thread t1 = new Thread(t);//创建了一个线程；
        Thread t2 = new Thread(t);//创建了一个线程；
        Thread t3 = new Thread(t);//创建了一个线程；
        Thread t4 = new Thread(t);//创建了一个线程；
        t1.start();
        t2.start();
        t3.start();
        t4.start();

    }
}

也可以手动加锁解决线程安全问题

/*
JDK1.5 中提供了多线程升级解决方案。
将同步Synchronized替换成现实Lock操作。
将Object中的wait，notify notifyAll，替换了Condition对象。
该对象可以Lock锁 进行获取。
该示例中，实现了本方只唤醒对方操作。

Lock:替代了Synchronized
	lock
	unlock
	newCondition()

Condition：替代了Object wait notify notifyAll
	await();
	signal();
	signalAll();
*/
class Resource {
    private String name;
    private int count = 1;
    private boolean flag = false;
    private Lock lock = new ReentrantLock();

    private Condition condition_pro = lock.newCondition();
    private Condition condition_con = lock.newCondition();
    
    public void set(String name) throws InterruptedException {
        lock.lock();
        try {
            while (flag)
                condition_pro.await();//t1,t2
            this.name = name + "--" + count++;

            System.out.println(Thread.currentThread().getName() + "...生产者.." + this.name);
            flag = true;
            condition_con.signal();
        } finally {
            lock.unlock();//释放锁一定要执行。
        }
    }
    
    public void out() throws InterruptedException {
        lock.lock();
        try {
            while (!flag)
                condition_con.await();
            System.out.println(Thread.currentThread().getName() + "...消费者........." + this.name);
            flag = false;
            condition_pro.signal();
        } finally {
            lock.unlock();
        }

    }
}

class Producer implements Runnable {
    private Resource res;

    Producer(Resource res) {
        this.res = res;
    }

    public void run() {
        while (true) {
            try {
                res.set("+商品+");
            } catch (InterruptedException e) {
            }

        }
    }
}

class Consumer implements Runnable {
    private Resource res;

    Consumer(Resource res) {
        this.res = res;
    }

    public void run() {
        while (true) {
            try {
                res.out();
            } catch (InterruptedException e) {
            }
        }
    }
}

class ProducerConsumerDemo {
    public static void main(String[] args) {
        Resource r = new Resource();

        Producer pro = new Producer(r);
        Consumer con = new Consumer(r);

        Thread t1 = new Thread(pro);
        Thread t2 = new Thread(pro);
        Thread t3 = new Thread(con);
        Thread t4 = new Thread(con);

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

    }
}