阅读 29

多线程-Java与CSharp

​ C#和Java中的多线程有相同之处,和不同之处。接下来请看:

1.新建一个线程

Java创建线程:
  1. 一种方法是:自定义一个类,继承Thread类,且重写其中的run()方法:例如:

public class NewThread extends Thread{ //继承Tread类

    @Override	//重写run()方法

    public void run(){

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

        System.out.println("this is another thread" + i);

    }

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

        NewThread thread = new NewThread();

        thread.start(); //自定义线程开始。

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

            System.out.println("this is main thread" + i);

        }

    }

}



复制代码
  1. 另一种方法是:自定义个一类,继承Runable接口,并重写接口中的run()方法:例如;

public class NewRunable implement Runable{ //继承Runable接口

    @Override	//重写run()方法

    public void run(){

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

        System.out.println("this is another thread" + i);

    }

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

        NewRunable runable = new NewRunable();

        Thread thread = new Thread(runable,)

        thread.start(); //自定义线程开始。

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

            System.out.println("this is main thread" + i);

        }

    }

}

复制代码
C#创建线程:

​ 通过创建一个Thread类接收一个ThreadStart委托或ParameterizedThreadStart委托,委托中包含新线程执行的的方法,例如:


    class Program {

        static void Main(string[] args) {

            ThreadStart threadStart = new ThreadStart(Run);

            Thread thread = new Thread(threadStart);

            thread.Start();

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

                Console.WriteLine("this is main thread" + i);

            }

            Console.ReadKey();

        }

//线程要

        static void Run() {

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

                Console.WriteLine("this is another thread" + i);

            }

        }

    }

}

复制代码

2. 线程安全问题

线程的生命周期:

创建 ------->start()------->可运行状态(具备等待CPU的资格,不具备CPU的执行权)------->得到CPU的执行权-------->运行状态(具备等待CPU和CPU的执行资格)(运行状态和可运行状态可相互装换)-------->完成任务-------->死亡状态


sleep(ms) : 进入临时阻塞状态,那么线程一旦超过了指定了睡眠时间,那么就会重新进入可运行状态,

wait:需要其他线程唤醒该线程才可以重新进入可运行状态。

复制代码
引起线程安全问题的条件:1. 在多线程的环境下;2. 线程中有共享数据;3. 共享数据有多条语句操作,执行。
复制代码
Java中线程安全问题的解决方案:
  1. 使用同步代码块, synchronize([锁对象])

    (Note:锁对象可以是任何对象(object),切是唯一共享的,否则无效。(最简单的定义一个锁可以使用 字符串)

    我们使用一个比较典型的例子来实现此问题(售票窗口售票的问题)

    
    class SaleWindow extends Thread{
    
        public static int num = 50;      //售票的剩余数
    
        public SaleWindow(String name){super(name);}
    
        @Override
    
        public void run(){
    
            while(true){
    
                synchronized("lock"){
    
                    if(num > 0){
    
                        System.out.println(this.getName() + "销售了第:" + num + "票");
    
                        try{
    
                            Thread.sleep(100);
    
                        }catch(InterruptedException e){
    
                            e.printStackTrace();
    
                        }
    
                        num--;
    
                    } else{
    
                        System.out.println("售完");
    
                        break;
    
                    }
    
                }
    
            }
    
        }
    
    }
    
    public class Sale {
    
        public static void main (String[] args){
    
            SaleWindow win1 = new SaleWindow("窗口1:");
    
            SaleWindow win2 = new SaleWindow("窗口2:");
    
            SaleWindow win3 = new SaleWindow("窗口3:");
    
    
    
            win1.start();
    
            win2.start();
    
            win3.start();
    
        }
    
    }
    
    复制代码

    2.同步方法:使用 synchronize 修饰一个方法: public synchronize void run()

    NOTE:

    1. 如果是一个非静态的同步函数的锁对象是this对象,如果是静态的同步函数的锁对象是当前函数所属的字节码字节(class对象)

    2. 同步函数的锁对象是固定的,不能自定义;

C#中线程安全的解决方案:
  1. lock关键字

    类似于Java中的同步代码块,lock(“锁”){执行代码} 。不同的是lock中的参数只能是引用类型,因为如果使用基本类型所谓锁,这每次都会发生装箱操作,则每次lock中都会重新new一个对象。

    NOTE:

    1. 尽量不要在public的类中使用lock,因为如此使用此类时,在不知情的情况下则会很容易造成死锁

    2. 尽量不要用public的字段作为锁,也会容易造成死锁;

    3. 不要用一个字符串作为锁,因为字符串被CLR“暂留”,就是说整个应用程序中给定的字符串都只有一个实例,因此更容易造成死锁现象。


    class Demo2 {

        static int num = 50;

        static object lockThe = new object();

        static void Run() {

            while (true) {

                lock (lockThe) {

                    if (num > 0) {

                        Console.WriteLine(Thread.CurrentThread.Name + "销售了第:" + num + "票");

                        try {

                            Thread.Sleep(100);

                        }

                        catch (Exception e) {

                            Console.WriteLine(e.StackTrace);

                        }

                        num--;

                    }

                    else {

                        Console.WriteLine("售完..");

                        break;

                    }

                }

            }

        }



        public static void Main(string[] args) {

            ThreadStart start = new ThreadStart(Run);

            Thread win1 = new Thread(start);

            Thread win2 = new Thread(start);

            win1.Name = "第一个窗口";

            win2.Name = "第二个窗口";

            win1.Start();

            win2.Start();

            Console.ReadKey();

        }

    }



复制代码
  1. Monitor

    Monitor与lock类似,lock(object){} 等效于 Monitor.Enter(object)......Monitor.Exit(object).

    
    lock (object){
    
        Run();
    
    }
    
    等效于:
    
    Monitor.Enter(object);
    
    try{
    
        Run();
    
    }
    
    finally{
    
        Monitor.Exit(object);
    
    }
    
    复制代码
  2. Mutex

    Mutex也是与Monitor类似,不过Mutex 有一个很大的特点,Mutex是跨进程的(博主不是很懂,会深入学习)。

  3. Interlocked

    如果只是对整形数据进行简单的操作,可以使用Interlocked来实现同步。此类的方法有:Increment(ref i)(对整数加一个),Decrement(ref i)(对整数减一个),Exchange(ref i , 100)与将i变为100,CompareExchange(ref i, 10 , 100),比较两个值,如果i与100相同,则i将变成10,否则不变。

关注下面的标签,发现更多相似文章
评论