Java学习总结（四）

多线程中的问题及解决

一般的线程中会遇到一些安全问题，那么如何解决？

 校验一个多线程程序是否有安全问题的隐患的前提条件:
 *                 1)当前程序是否是多线程环境
 *                 2)是否有共享数据
 *                 3)是否有多条语句对共享数据进行操作

 * 看当前案例是否有多线程的安全问题:

 *         1)是否是多线程环境        是
 *         2)是否有共享数据        是
 *         3)是否有多条语句对共享数据进行操作  是

 * 现在就需要解决安全问题:
 *         1)多线程环境        不能解决
 *         2)对共享数据进行优化    不能解决
 *         3)解决将多条语句对共享数据这一环进行解决
 *

 *         解决方案:就是将多条语句对共享数据操作的代码,用一个代码包起来---->代码--->同步代码块

 格式:

 *             synchronized(锁对象){
 *                     针对多条语句对共享数据操作代码;
 *             }
 *
 *         锁对象:肯定一个对象,随便创建一个对象(匿名对象)
 *         给刚才的这个程序加入了同步代码块,但是锁对象使用的匿名对象(每一个线程进来都有自己的锁),还是没有解决!
 *

 锁对象:每一个线程最总使用的锁对象,只能是同一把锁     这是一定需要注意的

 同步代码块举例：
 *        火车上上厕所(锁对象:将它看成是门的开和关)
 *
 *         synchronized(锁对象){
 *                 多条语句对共享数据操作的代码;
 *         }
 *
 注意:
 *        锁对象:一定要同一个锁(每个线程只能使用同一把锁)
 *        锁对象:任何的Java类(引用类型)

两种线程同步方法：

        如果一个方法的定义一开始就是同步代码块，那么可以将此方法用synchronized来修饰，该方法为非静态同步方法。
            非静态的方法:同步方法(需要底层源码,一些方法会声明synchronized)的锁对象:this
            静态的同步方法:和反射有关 (静态同步方法的锁对象:类名.class)

        
        public static List synchronizedList(List list)
        返回指定列表支持的同步（线程安全的）列表
        List list = Collections.synchronizedList(array)      线程安全的方法

    Jdk5.0以后,java提供了一个具体的锁:    Lock接口

    private Lock lock= new ReentrantLock();

    显式获取锁的前提,一定要创建Lock接口对象，最后一定要释放锁

      

                //try...finally

            try {    
                 lock.lock(); //获取锁 类似于syncrhonized(obj) if (条件) { try {
                         Thread.sleep(100); } catch (InterruptedException e) { e.printStackTrace(); } }

            //释放锁

} finally { if(lock!=null) { lock.unlock(); } }
上述方法虽然解决了多线程安全问题,但是还是有些问题:
        1)执行效率低
        2)会产生死锁

死锁：两个或两个以上的线程,在执行的过程中出现互相等待的情况

等待唤醒机制：

     synchronized(锁对象){
        相关条件下{
            相关操作
            锁对象.wait(); 立即释放锁
        }
    
        别的情况下{
            相关操作
            锁对象.notify;         作用是唤醒当前的wait()线程
        }

    }

 线程组和线程池

 *    程组表示一个线程的集合。此外，线程组也可以包含其他线程组

 *    线程池(某个线程执行完毕,反复利用线程对象)

线程组实例：

public static void main(String[] args) {
        
        //获取线程组的名称
          method1();
        
        //如何给多个线程设置一个线程组名称呢?
          method2();
    }

    private static void method2() {
       //  public ThreadGroup(String name)  构造一个新线程组
        ThreadGroup tg = new ThreadGroup("main-新的线程组") ;
        
        MyThread my = new MyThread() ;
        
       //  Thread(ThreadGroup group, Runnable target, String name)
        Thread t1 = new Thread(tg, my, "线程1") ;
        Thread t2 = new Thread(tg, my, "线程2") ;
        
        //直接获取线程组名称
        System.out.println(t1.getThreadGroup().getName());
        System.out.println(t2.getThreadGroup().getName());
    }

    private static void method1() {
        MyThread my = new MyThread() ;
        //创建线程类对象
        
        Thread t1 = new Thread(my, "线程1") ;
        Thread t2 = new Thread(my, "线程2") ;
        
        //public final ThreadGroup getThreadGroup()返回该线程所属的线程组
        ThreadGroup tg1 = t1.getThreadGroup() ;
        ThreadGroup tg2 = t2.getThreadGroup() ;
        
        //public final String getName():返回线程组的名称
        System.out.println(tg1.getName()); //main
        System.out.println(tg2.getName());//main
        
        //所有的线程它默认的线程组名称:main(主线程)
        System.out.println(Thread.currentThread().getThreadGroup().getName());//main
    }

 线程池 :多个线程执行完毕,它会重新回到线程池中,等待被利用,不会变成垃圾!
 线程池有关的类
 *    类 Executors: 一种工厂类
 *
 *        方法:
 *            和线程池的创建有关系
 *            public static ExecutorService newFixedThreadPool(int nThreads)

 *            创建一个可重用固定线程数的线程

 *            ExecutorService:可以执行异步任务

 *            线程池调用完毕可以关闭的
 *            void shutdown():关闭之前,会提交刚才的任务

 示范：

    public static void main(String[] args) {
        
        //创建一个线程池
        ExecutorService pool = Executors.newFixedThreadPool(2);
        //提交和Runnable接口的方法或者Callable(提交任务)
        pool.submit(new MyRunnable());
        pool.submit( new MyRunnable()) ;
        
        //pool-1-thread-2 :线程池-池数-线程类对象的描述-编号(从1开始)
        
        
        //关闭线程池
        pool.shutdown();
    }

 
 *            创建一个线程池,执行接口中的方法
 *                提交:Future submit(Runnable task)
 *                     Future submit(Callable task)提交一个返回值的任务用于执行，返回一个表示任务的未决结果的    Future
 *            Future:接口
 *                Future 表示异步计算的结果


Future接口实例：

 

   public static void main(String[] args) throws Exception, ExecutionException {
        
        ExecutorService pool = Executors.newFixedThreadPool(2);
        
        Future f1 = pool.submit(new MyCallable1(100));
        Future f2 = pool.submit(new MyCallable1(200));
        
        //V get():获取结果   //使用该方法时注意抛出异常
            Integer i1 = f1.get();
            Integer i2 = f2.get();
                
            System.out.println(i1);
            System.out.println(i2);
                
            //关闭线程池
            pool.shutdown();
     }

Java设计原则和设计模式

设计原则:

    1:  单一职责原则:
                低耦合,高内聚
            耦合性:类与类之间产生的关系
                低耦合:让类与类之间的关系不复杂
            内聚:执行一个件事情(功能)的能力
            高内聚:一个类能够完成的事情,不要使用多个类一起来执行!
            
        数据库
            对某个数据进行增删改查(查询很重要的)
            定一个接口:   {  增(); 删(); 改(); 查(); }

            实现类:
                业务逻辑层:
                    增() {
                        具体实现
                    }
                

    2:  开闭原则   

            核心思想是：一个对象对扩展开放，对修改关闭

                开发好一个程序(项目),尽量不要修改原有代码
                    类和类之间假设有关系
                        更改一个类的功能,其他类已需要更改(增加代码的代码的书写量)
                SVN(版本控制)/git
    



设计模式:
创建型模式 对象的创建
        
结构型模式 对象的组成(结构)
行为型模式 对象的行为
 简单工厂模式--->静态工厂方法模式

 *    设计一个工厂类:
 *        工厂类提供一些静态方法,间接的去创建具体的对象
 *
 *    优点:    不需要在创建具体类的对象,而是把创建的工作交给了工厂类来创建!
 *    弊端:    如果有新的对象增加，或者某些对象的创建方式不同，就需要不断的修改工厂类，不利于后期的维护

 
 工厂方法模式
 *        提供一个抽象类(抽象工厂)还需要提供一个接口(工厂接口),每一个具体的类都有对应的工厂类(实现工厂接口)
 *        具体对象的创建工作由继承抽象工厂的具体类实现
 *
 *    优点:
 *        客户端不需要在负责对象的创建(不需显示创建具体对象)，从而明确了各个类的职责，
 *        如果有新的对象增加，只需要增加一个具体的类和具体的工厂类即可，不影响已有的代码，后期维护容易，增强了系统的   扩展性
 *    弊端:
 *        书写代码量大了!


 设计模式之单例模式
 *        单例模式核心思想:某些类的对象在创建的时候 ,在系统内存始终只有一个对象!
 *        单例模式分类:
 *            1)饿汉式
 *            2)懒汉式(类似于多线程环境..)
 *
 *    饿汉式:
 *        在加载那个类的时候,对象的创建工作就已经完成了!
 *     懒汉式:
 *         符合单例模式核心思想
 *         1)自定义一个类,将无参构造私有化
 *         2)在成员位置声明静态该类对象并初始化为null！
 *         3)提供公共静态功能,在静态功能方法中判断是否需要创建该类对象,然后返回该类对象
 *
 * 如果是开发中,那么就使用饿汉式(饿汉式它不会出现问题的单例模式)
 * 如果是面试中,那么使用懒汉式(因为他是可能出现问题的一种单例模式)
 *
 * 面试题:
 *         你使用过单例模式吗?简单介绍一种单例模式,请用代码设计
 *                 面试官想问的是:使用设计单例的懒汉式,能否想到使用同步机制解决线程的安全问题..
 *
 * 懒汉式(延迟加载 -->懒加载)
 *             可能会出现问题
 *                     --->    多线程的问题
 *                     --->校验多线程安全问题的标准
 *                         1)是否是多线程环境
 *                         2)是否有共享数据
 *                         3)是否有多条语句对共享数据进行操作  (使用同步机制进行操作)
 *                
 *
 *
 两种分类在设计上几乎一样:
 *        1)定义个类,将该类的无参构造方法私有化
 *        2)在该类的成员位置创建该类对象 并且一定要私有化,防止外界更改这个对象
 *        3)在该类中提供静态成员方法(返回值就是创建的那个对象),能被当前类直接调用,static修饰

 Runtime
 * 每个 Java 应用程序都有一个 Runtime 类实例，使应用程序能够与其运行的环境相连接。

    // public static Runtime getRuntime()  返回与当前 Java 应用程序相关的运行时对象
    //   public Process exec(String command)
             throws IOException在单独的进程中执行指定的字符串命令。
        
    Runtime r = Runtime.getRuntime() ;
        //开启某一个进程 
        r.exec("notepad") ;打开记事本
        r.exec("mspaint") ;打开画图

Java网络编程

网络通信三要素
    1)ip地址
    2)端口号
    3)协议(协议UDP/TCP)

IP地址:     点分十进制法:十进制.十进制.十进制.十进制

IP地址的组成： IP地址 = 网络号码+主机地址

Ip地址的分类:

            A类IP地址:第一段号码为网络号码，剩下的三段号码为本地计算机的号码
                    一般情况:国防部/大的国部门
            B类IP地址:前二段号码为网络号码，剩下的二段号码为本地计算机的号码
                        一般情况:大学里面的多媒体教室
            C类IP地址:前三段号码为网络号码，剩下的一段号码为本地计算机的号码
                        私人地址
端口号:    0~65535有效端口号
               0-1024属于保留端口
               mysql:3306

协议:
    1）UDP协议    --->UDP编程
            不需要建立连接通道的
            数据大小有限制
            不可靠连接
            执行效率高
    2）TCP协议    ---->TCP编程
            需要建立连接通道
            数据大小无限制
            可靠连接
            执行效率低

InetAddress：该类表示互联网协议 (IP) 地址

 
 如果一个类中没有构造方法,没有字段,只有成员方法?有什么特征
     1)应该有一些静态功能(Math类,Arrays,Collections...)
     2)可能符合一种单例模式(饿汉/懒汉)
     3)该类中的某些静态成员方法的返回值是该类本身
 
 常用方法:
 * public static InetAddress getByName(String host)
        throws UnknownHostException在给定主机名的情况下确定主机的 IP 地址。
        参数:
            主机名可以是机器名（如 "java.sun.com"），也可以是其 IP 地址的文本表示形式
 

        //创建InetAddress对象,通过来获取ip地址

        //在知道主机名的情况下
        InetAddress address = InetAddress.getByName("USER-20171205ZR") ;
        
        //Ip地址对象
        InetAddress address = InetAddress.getByName("192.168.10.1") ;
        
        //上面获取到了Ip地址
        public String getHostAddress()  返回 IP 地址字符串（以文本表现形式）。
        String ip = address.getHostAddress() ;
        
        public String getHostName()  获取此 IP 地址的主机名。
        String name = address.getHostName() ;

简单UDP编程的接收端开发步骤：
 *        1)创建Socket对象
 *        2)创建一个数据报包(接收容器)
 *        3)调用Socket对象中的接收的方法
 *        4)解析实际传递的数据
 *        5)将解析的数据(ip,数据)展示在控制台上
 *        6)关闭资源

 *        注意：接收端不要运行多次,会出现异常:常开就好

示例：

    //1)创建Socket对象
    //public DatagramSocket(int port)创建数据报包套接字对象并且将其绑定到本地主机上的指定端口
        DatagramSocket ds = new DatagramSocket(10086);
        
    //    2)创建一个数据报包(接收容器)
    //public DatagramPacket(byte[] buf, int length)
        byte[] bys = new byte[1024] ;
        int len = bys.length ;
        DatagramPacket dp = new DatagramPacket(bys, len) ;
        
    //   3)调用Socket对象中的接收的方法
    //public void receive(DatagramPacket p):接收数据报包
        ds.receive(dp);//阻塞式方法
        
    //    获取ip地址文本形式
    //public InetAddress getAddress() :返回ip地址对象  数据报包类:DataGramPacket
        InetAddress address = dp.getAddress() ;
        String ip = address.getHostAddress() ;
    //    4)解析实际传递的数据
    //public byte[] getData() :获取缓冲中实际数据(从接收容器中获取)
        byte[] bys2  = dp.getData() ;
        
    //public int getLength() 返回将要发送或接收到的数据的长度。
        int len2 = dp.getLength() ;//从接收容器中获取包的实际长度
        
        String data = new String(bys2, 0, len2) ;
        
        System.out.println("当前接收到的数据是:"+data+",来自于"+ip);
        
     //   6)关闭资源
        ds.close();

Udp编程发送端
 *    1)不需要建立连接通道
 *    2)数据大小有限制
 *    3)不可靠连接---->传输速度快!
 *
 * 发送端的开发步骤:
 *         1)创建发送端的Socket对象
 *         2)创建数据,并打包
 *         3)调用当前发送端Socket对象中的发送的方法
 *         4)关闭资源

	public static void main(String[] args) throws IOException {
		///1)创建发送端的Socket对象
		//DatagramSocket:此类表示用来发送和接收数据报包的套接字。
		//创建DataGramSocket对象
		//构造方法
		//public DatagramSocket(int port,InetAddress laddr)
		//这个构造方法,里面传递并不是Ip地址的文本形式
		//构造数据报套接字并将其绑定到本地主机上任何可用的端口
		DatagramSocket ds = new DatagramSocket() ;
		
	  	//	2)创建数据,并打包
		//DatagramPacket 数据报包
		//DatagramPacket(byte[] buf, int offset, int length, InetAddress address, int port)
		/**
		 * buf - 包数据。
			offset - 包数据偏移量。
			length - 包数据长度。
			address - 目的地址。
			port - 目的端口号。
		 */
		//有数据
		byte[] bys = "hello,udp,我来了".getBytes() ;
		//获取包数据长度
		int len = bys.length ;
		//获取ip地址对象
		InetAddress address = InetAddress.getByName("192.168.10.1") ;
		//指定端口号
		int port = 10086 ;
		DatagramPacket dp =new DatagramPacket(bys, 0, len, address, port) ;
	  	//	3)调用当前发送端Socket对象中的发送的方法
		/*public void send(DatagramPacket p)
		          throws IOException从此套接字发送数据报包*/
		ds.send(dp);
	  	//	4)关闭资源*
		ds.close();
	}
}

小结：

        掌握的其实都不是很好暂时，网络编程有了大致的了解

        对于设计模式和原则有了比较清晰的认识，特别是单例模式。了解设计模式确实是有助于提高代码质量

        学习判断多线程编程中存在的安全问题，解决安全问题的同时避免死锁的产生，熟悉线程的等待唤醒机制，学习运用线程组和线程池，了解线程池的特点。