java多线程有哪些优点?同步实例代码展示

BSO 2020-11-17 16:32:13 java常见问答 5961

在我们的日常学习当中会发现java的知识点是总是息息相关的,可以串联起来。java中多线程的有关内容可以衍生出更多知识,它的优缺点也是非常明显的。你都了解吗?一起来看看吧。

首先为大家介绍一下,多线程(多个线程同时运行)程序的优缺点

优点:

⑴可以减轻系统性能方面的瓶颈,因为可以并行操作;

⑵提高CPU的处理器的效率,在多线程中,通过优先级管理,可以使重要的程序优先操作,提高了任务管理的灵活性;

另一方面,在多CPU系统中,可以把不同的线程在不同的CPU中执行,真正做到同时处理多任务。

缺点:

⑴开启线程需要占用一定的内存空间(默认情况下,主线程占用1M,子线程占用512KB),如果开启大量的线程,会占用大量的内存空间,降低程序的性能

⑵线程越多,CPU在调度线程上的开销就越大

⑶程序设计更加复杂:比如线程之间的通信、多线程的数据共享

然后为大家展示一下同步的实例代码:

Demo1:
    package test.thread;
class SynTest
{
    //非同步
    static void method(Thread thread)
    {
        System.out.println("begin " + thread.getName());
        try
        {
            Thread.sleep(2000);
        }
        catch (Exception ex)
        {
            ex.printStackTrace();
        }
        System.out.println("end " + thread.getName());
    }
    //同步方式一:同步方法
    synchronized static void method1(Thread thread)
    { //这个方法是同步的方法,每次只有一
        个线程可以进来
        System.out.println("begin " + thread.getName());
        try
        {
            Thread.sleep(2000);
        }
        catch (Exception ex)
        {
            ex.printStackTrace();
        }
        System.out.println("end " + thread.getName());
    }
    //同步方式二:同步代码块
    static void method2(Thread thread)
    {
        synchronized(SynTest.class)
        {
            System.out.println("begin " + thread.getName());
            try
            {
                Thread.sleep(2000);
            }
            catch (Exception ex)
            {
                ex.printStackTrace();
            }
            System.out.println("end " + thread.getName());
        }
    }
    //同步方式三:使用同步对象锁
    private static Object _lock1 = new Object();
    private static byte _lock2[] = {}; //据说,此锁更可提高性能。源于:锁的对象越小越好
    static void method3(Thread thread)
    {
        synchronized(_lock1)
        {
            System.out.println("begin " + thread.getName());
            try
            {
                Thread.sleep(2000);
            }
            catch (Exception ex)
            {
                ex.printStackTrace();
            }
            System.out.println("end " + thread.getName());
        }
    }
    public static void main(String[] args)
    {
        //启动3个线程,这里用了匿名类
        for (int i = 0; i < 3; i++)
        {
            new Thread()
            {
                public void run()
                {
                    method(this);
                    //method1(this);
                    //method2(this);
                    //method3(this);
                }
            }.start();
        }
    }
}
Demo2:
    package test.thread;
import com.util.LogUtil;
public class SynTest2
{
    public static void main(String[] args)
    {
        Callme target = new Callme();
        Caller ob1 = new Caller(target, "Hello");
        Caller ob2 = new Caller(target, "Synchronized");
        Caller ob3 = new Caller(target, "World");
    }
}
class Callme
{
    synchronized void test()
    {
        LogUtil.log("测试是否是:一旦一个线程进入一个实例的任何同步方法,别的线程将不能
            进入该同一实例的其它同步方法, 但是该实例的非同步方法仍然能够被调用 ");
        }
        void nonsynCall(String msg)
        {
            LogUtil.log("[" + msg);
            LogUtil.log("]");
        }
        synchronized void synCall(String msg)
        {
            LogUtil.logPrint("[" + msg);
            LogUtil.log("]");
        }
    }
    class Caller implements Runnable
    {
        String msg;
        Callme target;
        Thread t;
        Caller(Callme target, String msg)
        {
            this.target = target;
            this.msg = msg;
            t = new Thread(this);
            t.start();
        }
        public void run()
        {
            // TODO Auto-generated method stub
            //target.nonsynCall(msg);
            target.synCall(msg);
            target.test();
        }
    }

同步的实例代码还是非常详细的,这也是与线程有关的比较繁琐的知识点。如果你对java知识非常有兴趣,想要了解更多java实例,敬请关注奇Q工具网。

推荐阅读:

java阻塞队列有哪些?同步集合类有哪些?

java实现同步机制有哪些?详细解析

java多线程同步与异步的关键字,详细解析