java 线程和进程

 

 

 

 

一个进程中肯定，至少有一个线程。

多线程可以并发运行。一个病人和多个医生操作。

线程之间的切换远远高于进程之间的切换效率。所以用多线程替代多进程。

 

 

 

java.lang.Thread
一个Thread对象代表一个线程的对象



public class MyThread extends Thread{
    public void run()
    {
        System.out.println(getName());
    }
}
public class TestThread {
    public static void main(String[] args)
    {
        MyThread mt = new MyThread();
        mt.start();
        System.out.println("main:"+Thread.currentThread().getName());
    }
}


/*
结果是：
main:main//先打印main方法，因为多进程有时间片的切换。
Thread-0
*/


public class MyThread extends Thread{
    public void run()
    {
        while(true) //死循环
        System.out.println(getName());
    }
}
public class TestThread {
    public static void main(String[] args)
    {
        MyThread mt = new MyThread();
        mt.start();
while(true)//死循环
        System.out.println("main:"+Thread.currentThread().getName());
    }
}

//增加死循环就可以看到多进程的时间片切换




public class TestThread {
    public static void main(String[] args)
    {
        MyThread mt = new MyThread();
        mt.setDaemon(true);//在start之前使用，将该线程标记为守护线程或用户线程。
        mt.start();
        while(true)
        {
            System.out.println("main:"+Thread.currentThread().getName());
           
        }
    }
}

public class MyThread extends Thread{
    public void run()
    {
        while(true)
        {
            System.out.println(getName());
            yield();//暂停当前正在执行的线程对象，并执行其他线程。
        }
    }
}


mt.setPriority(Thread. MAX_PRIORITY _);//修改为最高的优先级

 

 

 

 

 

 

 

 

 

java.lang.Runnable 对于一个类来说，如果它的实例想要被一个线程去执行，那么就应该实现Runnable接口，那么这个类必须实现一个不带参数的run方法


class MyThread implements Runnable{
    public void run()
    {
        while(true)
        {
            System.out.println(Thread.currentThread().getName());
        }
    }
}
class TestThread {
    public static void main(String[] args)
    {
        MyThread mt = new MyThread();
        new Thread(mt).start();
        int index=0;
        while(true)
        {
            System.out.println("main:"+Thread.currentThread().getName());
           
        }
    }
}



两者的优缺：
如果并不需要修改线程中除了run方法之外的其它方法行为以外，我们最好都是去实现Runnabel接口；java不允许多继承，可以用实现接口来实现多线程；如果要达到共享同一个变量，继承类的实例就不行，最好是实现接口来共享一个成员变量



利用内部类：
class MyThread {
    int index=0;
    private class InnerThread extends Thread
    {
        public void run()
        {
            while(true)
            {
                System.out.println(Thread.currentThread().getName());
            }
        }
    }
    Thread getThread()
    {
        return new InnerThread();
    }
}
class TestThread {
    public static void main(String[] args)
    {
        MyThread mt = new MyThread();
        mt.getThread().start();
        mt.getThread().start();
        mt.getThread().start();
        mt.getThread().start();
        while(true)
        {
            System.out.println("main:"+Thread.currentThread().getName());
           
        }
    }
}


火车票售票系统：多线程来实现
class MyThread implements Runnable{
    int tickets=100;
    public void run()
    {
        while(true)
        {
            if(tickets>0)
            {
                System.out.println(Thread.currentThread().getName()+"sell tickets:"+tickets);
                tickets--;
            }
        }
    }
}

class TestThread {
    public static void main(String[] args)
    {
        MyThread mt = new MyThread();
        new Thread(mt).start();
        new Thread(mt).start();
        new Thread(mt).start();
        new Thread(mt).start();
    }
}



问题是没有锁关键步骤，应该加上同步块
class MyThread implements Runnable{
    int tickets=100;
    Object obj = new Object();
    public void run()
    {
        while(true)
        {
            synchronized(obj)//同步块，需要一个对象，来加锁
            {
                if(tickets>0)
                {
                    try
                    {
                        Thread.sleep(10);
                    }
                    catch(Exception e)
                    {
                        e.printStackTrace();
                    }
                    System.out.println(Thread.currentThread().getName()+"sell tickets:"+tickets);
                    tickets--;
                }
            }
        }
    }
}


class TestThread {
    public static void main(String[] args)
    {
        MyThread mt = new MyThread();
        new Thread(mt).start();
        new Thread(mt).start();
        new Thread(mt).start();
        new Thread(mt).start();
    }
}
同步方法

class MyThread implements Runnable{
    int tickets=100;
    Object obj = new Object();
    public void run()
    {
        while(true)
        {
            sell();
        }
    }
    public synchronized void sell()
    {
        if(tickets>0)
        {
            try
            {
                Thread.sleep(10);
            }
            catch(Exception e)
            {
                e.printStackTrace();
            }
            System.out.println(Thread.currentThread().getName()+"sell tickets:"+tickets);
            tickets--;
        }
    }
}



class TestThread {
    public static void main(String[] args)
    {
        MyThread mt = new MyThread();
        new Thread(mt).start();
        new Thread(mt).start();
        new Thread(mt).start();
        new Thread(mt).start();
    }
}