精华内容
下载资源
问答
  • 上一节中讲了道路创建的三要素:平面路线(Alignment)、纵断面(Profile)、横断面(Assembly),今天就讲一下条件部件在道路模型中的表现以及道路的挖填方计算。 (1)条件部件 首先创建一个简单的条件部件如下...

    上一节中讲了道路创建的三要素:平面路线(Alignment)、纵断面(Profile)、横断面(Assembly),今天就讲一下条件部件在道路模型中的表现以及道路的挖填方计算。

    (1)条件部件

    首先创建一个简单的条件部件如下图,实现的功能就是:

    填方时:当填方高度小于5m时,直接一坡到地面;当填方高度大于5m时,会出现一级平台,然后再一坡到地面;

    挖方时:当挖方高度小于5m时,直接一坡到地面;当挖方高度大于5m时,会出现一级平台,然后再一坡到地面。  

     根据上节的步骤进行创建道路模型,见下图所示,仔细观察条件部件在道路模型中的表现。

     (2)道路的填挖方计算

    假定道路模型已经创建完成,本例中使用的横断面见下图: 

    若要进行道路的填挖方计算,首先要创建道路曲面,然后再创建采样线(sampleLine),civil3d根据采样线进行填挖方计算。

    右键道路模型【特性】调出道路模型特性对话框,在这里根据道路模型创建道路曲面。操作顺序见下图。

    最后点击确定即可创建道路曲面,这时【曲面】下面会包含类似于下图所示的曲面对象。

    下面创建采样线,在【常用】选项卡中点击【采样线】如下图: 

    随后屏幕会出现一个拾取框,这时按一下空格键,会弹出从列表选择路线对话框,然后选择要采样的路线,点击确定,弹出【创建采样线编组】对话框,设置如下: 

    点击确定后,【采样线工具】条被激活,如下图:

    点击【按桩号范围...】进行创建采样线: 

     点击后弹出如下对话框,设置如下,需要注意的是采样线的宽度,当道路模型比较宽时,采样线也要设置的宽一些。

    点击确定按钮,同时关闭【采样线工具】条。创建的采样线如下图,这时注意左侧的目录树中的【路线】--【路线中线】--“道路中心线”--【采样线编组】下会显示刚刚创建的采样线编组,在这就可以看出采样线是路线下的子对象,采样线依附于路线,也就是说路线是采样线的容器。一个路线下面可以同时创建多个独立的采样线编组。 

    最后一步就是计算填挖方量(在civil中叫计算材质ComputeMaterials)

    首先拾取任意一个前面创建的采样线,菜单面板中会自动显示更采样线有关的操作,如下图:

    点击【计算材质】命令后,跳出如下临时对话框,选择路线及采样线编组

    点击确定后,跳出【计算材质】对话框,设置如下,需要注意的是自然地面使用地形曲面,设计曲面使用道路模型生成的曲面。

    点击确定后,程序就会按照采样线设定的桩号间距根据平均断面面积进行计算,计算完成后采样线仍然处于选中状态,暂时不要按ESC键。 

    点击上图中左侧的【添加表】---【总体积】命令,弹出如下对话框: 

     最后单击确定按钮,在空白处插入总体积表,如下:

    到此填挖方计算的基本步骤已经讲完,这个过程需要多次使用,才能体会其中的细节。还有就是上面的总体积表的显示样式也是可以定制的,有兴趣的可以先摸索一下,后面也会有介绍的。谢谢,祝大家开心。

    转载自:https://www.cnblogs.com/whlkx/p/9062164.html

    展开全文
  • 如果条件允许,可用图形化界面创建更方便快捷 以root用户登录,敲./dbca,如果跳不出图形化界面,就用下面的手动创建 一、以oracle用户登录 二、获取oracle安装路径 [oracle@linux] echo $ORACL

    原文地址:http://blog.csdn.net/sunchenglu7/article/details/39676659


    如果条件允许,可用图形化界面创建更方便快捷

    以root用户登录,敲./dbca,如果跳不出图形化界面,就用下面的手动创建

    以oracle用户登录

    获取oracle安装路径

    [oracle@linux] echo $ORACLE_HOME

    [oracle@linux] cd $ORACLE_HOME

    [oracle@linuxoracle/product/11g/db] cd  dbs

    三、创建新实例的参数文件

    [oracle@10.14.54.199 dbs]$ ls

    hc_orcl2.dat  initdw.ora  initorcl.ora  lkORCL2    orapworcl2       spfileorcl.ora

    hc_orcl.dat   init.ora    lkORCL        orapworcl  spfileorcl2.ora

    [oracle@10.14.54.199 dbs]$ pwd

    /oracle/inst1/product/10.2.0/db_1/dbs

    [oracle@10.14.54.199 dbs]$ cp initorcl.ora initorcl3.ora

    注:这里我们通过拷贝原实例参数文件的方法进行创建,然后再进行修改。

    修改新实例的参数文件

    orcl.__db_cache_size=184549376

    orcl.__java_pool_size=4194304

    orcl.__large_pool_size=4194304

    orcl.__shared_pool_size=88080384

    orcl.__streams_pool_size=0

    *.audit_file_dest='/oracle/inst1/admin/orcl3/adump'

    *.background_dump_dest='/oracle/inst1/admin/orcl3/bdump'

    *.compatible='10.2.0.1.0'

    *.control_files='/oracle/inst1/oradata/orcl3/control01.ctl','/oracle/inst1/oradata/orcl3/control02.ctl','/oracle/inst1/oradata/orcl3/control03.ctl'

    *.core_dump_dest='/oracle/inst1/admin/orcl3/cdump'

    *.db_block_size=8192

    *.db_domain=''

    *.db_file_multiblock_read_count=16

    *.db_name='orcl3'

    *.db_recovery_file_dest='/oracle/inst1/flash_recovery_area'

    *.db_recovery_file_dest_size=2147483648

    *.dispatchers='(PROTOCOL=TCP) (SERVICE=orclXDB)'

    *.job_queue_processes=10

    *.log_archive_dest_1='location=/oracle/inst1/arch/orcl3'

    *.open_cursors=300

    *.pga_aggregate_target=94371840

    *.processes=150

    *.remote_login_passwordfile='EXCLUSIVE'

    *.sga_target=285212672

    *.undo_management='AUTO'

    *.undo_tablespace='UNDOTBS1'

    *.user_dump_dest='/oracle/inst1/admin/orcl3/udump'

    创建新实例的相关目录:

    [oracle@10.14.54.199 ~]$ cd /oracle/inst1/admin/

    [oracle@10.14.54.199 admin]$ mkdir orcl3

    [oracle@10.14.54.199 admin]$ ls

    orcl  orcl2  orcl3

    [oracle@10.14.54.199 admin]$ cd orcl3

    [oracle@10.14.54.199 orcl3]$ mkdir adump bdump cdump udump

    [oracle@10.14.54.199 orcl3]$ cd /oracle/inst1/oradata/

    [oracle@10.14.54.199 oradata]$ mkdir orcl3

    [oracle@10.14.54.199 oradata]$ ls

    orcl  orcl2  orcl3

    [oracle@10.14.54.199 oradata]$ pwd

    /oracle/inst1/oradata

    [oracle@10.14.54.199 oradata]$ ls

    orcl  orcl2  orcl3

    [oracle@10.14.54.199 oradata]$ cd ..

    [oracle@10.14.54.199 inst1]$ ls

    admin  arch  database  flash_recovery_area  libXp-1.0.0-8.1.el5.i386.rpm  oradata  oraInventory  product

    [oracle@10.14.54.199 inst1]$ cd arch

    [oracle@10.14.54.199 arch]$ ls

    orcl  orcl2

    [oracle@10.14.54.199 arch]$ mkdir orcl3

    [oracle@10.14.54.199 arch]$ ls

    orcl  orcl2  orcl3

    启动实例测试

    [oracle@10.14.54.199 arch]$ export ORACLE_SID=orcl3

    [oracle@10.14.54.199 arch]$ sqlplus /nolog

    SQL*Plus: Release 10.2.0.1.0 - Production on Wed Dec 5 17:46:40 2012

    Copyright (c) 1982, 2005, Oracle.  All rights reserved.

    SQL> conn /as sysdba;

    Connected to an idle instance.

    SQL> startup nomount;

    ORACLE instance started.

    Total System Global Area  285212672 bytes

    Fixed Size                  1218992 bytes

    Variable Size              92276304 bytes

    Database Buffers          188743680 bytes

    Redo Buffers                2973696 bytes

    SQL> select instance_name from v$instance;

    INSTANCE_NAME

    ----------------

    orcl3

    创建密码文件:(该步骤一定要执行,否则SYS没有SYSDBA权限登录)

    oracle@10.14.54.199 arch]$ orapwd file=”/oracle/inst1/product/10.2.0/db_1/dbs/orapworcl3” password=oracle entries=10;

    四、创建数据库

    4.1、编写数据库创建脚本

    下面为创建数据库的脚本:(注意:路径不要有空格)

    CREATE DATABASE orcl5

       USER SYS IDENTIFIED BY sys

       USER SYSTEM IDENTIFIED BY manager

       LOGFILE GROUP 1 ('/mnt/sda3/oracle/oradata/orcl5/redo01.log') SIZE 20M,

               GROUP 2 ('/mnt/sda3/oracle/oradata/orcl5/redo02.log') SIZE 20M,

               GROUP 3 ('/mnt/sda3/oracle/oradata/orcl5/redo03.log') SIZE 20M

       MAXLOGFILES 5

       MAXLOGMEMBERS 5

       MAXLOGHISTORY 1

       MAXDATAFILES 100

       MAXINSTANCES 1

       CHARACTER SET US7ASCII

       NATIONAL CHARACTER SET UTF8

       DATAFILE '/mnt/sda3/oracle/oradata/orcl5/system01.dbf' SIZE 325M REUSE

       EXTENT MANAGEMENT LOCAL

       SYSAUX DATAFILE '/mnt/sda3/oracle/oradata/orcl5/sysaux01.dbf' SIZE 325M REUSE

       DEFAULT TABLESPACE tbs_1 datafile '/mnt/sda3/oracle/oradata/orcl5/tbs_1.dbf' size 50m

       DEFAULT TEMPORARY TABLESPACE temp

          TEMPFILE '/mnt/sda3/oracle/oradata/orcl5/temp01.dbf'

          SIZE 20M REUSE

       UNDO TABLESPACE undotbs1

          DATAFILE '/mnt/sda3/oracle/oradata/orcl5/undotbs01.dbf'

          SIZE 200M REUSE AUTOEXTEND ON MAXSIZE UNLIMITED;

    4.3、验证是否创建成功

    查询数据库状态

    SQL> select status from v$instance;

    STATUS

    ------------

    OPEN

    SQL>

    4.4、运行后续脚本,创建数据字典及相关视图

    SQL>conn sys as sysdba

    SQL>@?/rdbms/admin/catalog.sql;

    此过程可能需要10分钟左右

    SQL>@?/rdbms/admin/catproc.sql;

    此过程可能需要15分钟左右

    SQL>@?/rdbms/admin/catblock.sql;

    SQL>@?/rdbms/admin/catoctk.sql;

    SQL>@?/rdbms/admin/owminst.plb;

    SQL>conn system/ manager

    SQL>@?/sqlplus/admin/pupbld.sql;

    SQL>@?/sqlplus/admin/help/hlpbld.sql helpus.sql

     

    五、客户端连接

    5.1、监听文件配置(listener.ora)

    SID_LIST_LISTENER =

      (SID_LIST =

        (SID_DESC =

          (SID_NAME = PLSExtProc)

          (ORACLE_HOME = /oracle/inst1/product/10.2.0/db_1)

          (PROGRAM = extproc)

        )

        (SID_DESC =

          (GLOBAL_DBNAME = orcl5)

          (ORACLE_HOME = /oracle/inst1/product/10.2.0/db_1)

          (SID_NAME = orcl5)

        )

      

        (SID_DESC =

          (GLOBAL_DBNAME = orcl3)

          (ORACLE_HOME = /oracle/inst1/product/10.2.0/db_1)

          (SID_NAME = orcl3)

        )

      )

    LISTENER =

      (DESCRIPTION_LIST =

        (DESCRIPTION =

          (ADDRESS = (PROTOCOL = TCP)(HOST = 10.14.54.199)(PORT = 1521))

        )

      )

    5.2、本地服务名称配置(tnsnames.ora)

    # Generated by Oracle configuration tools.

    ORCL =

      (DESCRIPTION =

        (ADDRESS = (PROTOCOL = TCP)(HOST = 10.14.54.199)(PORT = 1521))

        (CONNECT_DATA =

          (SERVER = DEDICATED)

          (SERVICE_NAME = orcl)

        )

      )


    展开全文
  • 创建一个C++线程类:C++中独立于平台的线程 简介 最近,有人问到,是否有一种简单的方法创建一个C++类,以便有助于编写面向对象的线程,而且这个线程类还要有以下属性:支持事件驱动及基于间隔的异步线程。...

    创建一个C++线程类:C++中独立于平台的线程


        简介
        最近,有人问到,是否有一种简单的方法创建一个C++类,以便有助于编写面向对象的线程,而且这个线程类还要有以下属性:


    支持事件驱动及基于间隔的异步线程。
    支持生成同种及特定的线程。
    提供一个FCFS(先来先服务)的堆栈队列用于发送及处理多任务。
    可移植。
    易于实现。


        为支持新类CThread,还需要编写出其他相关的类,这些类包括:CMutexClass、CEventClass、CTask,CMutexClass及CEventClass提供资源管理,而CTask是一个用于派生的基类,其支持同种异步线程。


        什么是线程?
        每个进程至少有一个控制线程,且每个进程在同一时间至少能执行一项任务,有多种控制线程的进程称为多线程进程,一个多线程进程可在自身环境内异步运行多个任务。


        资源管理——线程同步
        因为进程内的线程分享相同的资源,所以需要在系统级别上设置控制机制来保证数据的完整性。当一个线程修改了某个变量,而另一个线程试图读取它时,或者两个线程同时修改同一变量,就会影响到数据的完整性,为防止这个问题,操作系统提供了一种相互排斥对象,简写为mutex。在多线程程序中,mutex是通过编程来实现的,可防止多个线程在同一时间访问同一资源。当一个线程需要访问某一资源时,它必须先请求一个mutex,一旦线程得到一个mutex,其他想获取同一mutex的线程被阻塞,并处于低CPU占用的等待状态;一旦这个线程完成了数据访问,它会释放对应的mutex,这就允许其他线程获取以访问相关的数据。
        如果mutex实现得不好,将会导致资源饥饿,也就是常说的死锁。资源饥饿发生在当一个或多个线程竞争同一资源时,如果一个线程请求一个mutex两次,也可能会发生死锁。


    <!-- @page { margin: 2cm } TD P { margin-bottom: 0cm } P { margin-bottom: 0.21cm } -->

    线程A

    线程B

    请求mutex1修改数据项1

    请求mutex2修改数据项2

    想要mutex2查看数据项2

    想要mutex1查看数据项1




        在上表中,就会发生死锁,因为线程A想要获取mutex2时被阻塞,而它正被线程B所持有;线程B想要获取mutex1时被阻塞,而它正被线程A所持有。
        与mutex类似,Unix中的条件变量,也是一种同步机制。条件变量允许线程会合,可让一个线程在有变化时通知另一个线程,这在Windows中,被称为events。


        操作系统的调用
        下表列出的函数均可用于在CMutexClass、CEventClass、CTask及CThread类中实现线程。

    <!-- @page { margin: 2cm } P { margin-bottom: 0.21cm } -->

    函数

    操作系统

    描述

    使用的类

    CreateThread

    Windows

    创建一个Windows线程

    CThread

    pthread_create

    UNIX - POSIX THREADS

    创建一个UNIX线程

    CThread

    pthread_join

    UNIX - POSIX THREADS

    等待一个UNIX线程结束

    CThread

    pthread_attr_init

    UNIX - POSIX THREADS

    将某一线程属性结构设为默认

    CThread

    pthread_attr_setstacksize

    UNIX - POSIX THREADS

    设置线程属性结构的堆栈大小

    CThread

    WaitForSingleObject

    Windows

    等待一个对象有信号

    CThread, CMutexClass, CEventClass

    CreateMutex

    Windows

    创建一个命名或未命名的mutex

    CMutexClass

    CloseHandle

    Windows

    关闭某一Windows句柄以释放资源

    CMutexClass, CEventClass, CThread

    ReleaseMutex

    Windows

    释放某一之前获取,并由WaitForSingleObject锁定的 mutex

    CMutexClass, CEventClass

    pthread_mutexattr_init

    UNIX - POSIX THREADS

    初始化某一mutex属性结构

    CMutexClass, CEventClass

    pthread_mutex_init

    UNIX - POSIX THREADS

    用给定的属性结构初始化某一mutex

    CMutexClass, CEventClass

    pthread_mutex_lock

    UNIX - POSIX THREADS

    锁定某一mutex

    CMutexClass, CEventClass

    pthread_mutex_unlock

    UNIX - POSIX THREADS

    解锁某一之前由pthread_mutex_lock锁定的mutex

    CMutexClass, CEventClass

    pthread_mutex_destroy

    UNIX - POSIX THREADS

    释放分配给mutex的资源

    CMutexClass, CEventClass

    CreateEvent

    Windows

    创建一个Windows事件对象

    CEventClass

    SetEvent

    Windows

    设置某一Windows事件对象为有信号状态

    CEventClass

    pthread_cond_signal

    UNIX - POSIX THREADS

    解除由pthread_cond_wait阻塞的某一线程

    CEventClass

    pthread_cond_wait

    UNIX - POSIX THREADS

    基于条件变量进行阻塞

    CEventClass

    pthread_cond_init

    UNIX - POSIX THREADS

    初始化一个条件变量

    CEventClass





        类CMutexClass
        类CMutexClass封装了系统级的mutex函数及一个mutex同步对象,且提供了两个成员函数:Lock及Unlock。Lock成员函数锁定一个mutex并把它赋给一个调用线程,mutex一直保持锁定状态直到调用线程使用Unlock成员函数释放它。任何调用Lock成员函数想获取锁定mutex的线程将被阻塞,并置于低CPU占用的等待状态,直到有线程释放了mutex。


    CMutexClass::CMutexClass(void):m_bCreated(TRUE)
    {
    #ifdef WINDOWS
       m_mutex = CreateMutex(NULL,FALSE,NULL);
       if( !m_mutex ) m_bCreated = FALSE;
    #else
       pthread_mutexattr_t mattr;

       pthread_mutexattr_init( &mattr );
       pthread_mutex_init(&m_mutex,&mattr);

    #endif
       memset(&m_owner,0,sizeof(ThreadId_t));

    }

    CMutexClass::~CMutexClass(void)
    {
    #ifdef WINDOWS
       WaitForSingleObject(m_mutex,INFINITE);
       CloseHandle(m_mutex);
    #else
       pthread_mutex_lock(&m_mutex);
       pthread_mutex_unlock(&m_mutex);
       pthread_mutex_destroy(&m_mutex);
    #endif
    }

    /**
     *
     * Lock
     * 同一线程只能锁定同一mutex一次
     *
     **/
    void
    CMutexClass::Lock()
    {
       ThreadId_t id = CThread::ThreadId();
       try {
          if(CThread::ThreadIdsEqual(&m_owner,&id) )
             // mutex已被这个线程锁定
             throw "/n/t the same thread can not acquire a mutex twice!/n";
    #ifdef WINDOWS
          WaitForSingleObject(m_mutex,INFINITE);
    #else
          pthread_mutex_lock(&m_mutex);
    #endif
          m_owner = CThread::ThreadId();
       }
       catch( char *psz )
       {
    #ifdef WINDOWS
          MessageBoxA(NULL,&psz[2],"Fatal exception CMutexClass::Lock",
                      MB_ICONHAND);
          exit(-1);
    #else
          cerr << "Fatal exception CMutexClass::Lock : " << psz;
    #endif


       }

    }

    /**
     *
     * Unlock
     * 只有获取该mutex的线程能释放它
     *
     **/
    void
    CMutexClass::Unlock()
    {
       ThreadId_t id = CThread::ThreadId();
       try
       {
          if( ! CThread::ThreadIdsEqual(&id,&m_owner) )
          throw "/n/t only the thread that acquires a mutex can
                 release it!";

          memset(&m_owner,0,sizeof(ThreadId_t));
    #ifdef WINDOWS
          ReleaseMutex(m_mutex);
    #else
          pthread_mutex_unlock(&m_mutex);
    #endif
       }
       catch ( char *psz)
       {
    #ifdef WINDOWS
          MessageBoxA(NULL,&psz[2],"Fatal exception CMutexClass::Unlock",
                      MB_ICONHAND);
          exit(-1);
    #else
          cerr << "Fatal exception CMutexClass::Unlock : " << psz;
    #endif

       }
    }


    <!-- @page { margin: 2cm } P { margin-bottom: 0.21cm } -->

    函数

    描述

    void CMutexClass()

    构造函数

    void Lock()

    锁定mutex对象或当它阻塞时等待

    void Unlock()

    解锁之前阻塞的mutex




    int g_iStorage = 0;
    CMutexClass MyMutex;

    void StoreValue( int *pInt )
    {
       MyMutex.Lock();           //它可是“掌门人”喔,一个只允许一个线程。

          g_iStorage = *pInt;    //受保护的数据,关键代码段。

       MyMutex.Unlock();         //解锁,允许其他线程访问g_iStorage
    }


        类CEventClass
        类CEventClass封装了Windows事件函数、Windows事件对象、Unix条件变量函数、Unix条件变量。集成到CEventClass类中的函数分别为Windows下的SetEvent及CreateEvent,Unix下的htread_cond_init、pthread_cond_destroy、pthread_cond_signal、pthread_cond_wait。在Unix下,为了简单起见,事件同步对象被称为条件变量,在此我们把条件变量及事件对象均称为事件对象。


    #include "Thread.h"


    #include <iostream>
    using namespace std;

    CEventClass::CEventClass(void):m_bCreated(TRUE)
    {
       memset(&m_owner,0,sizeof(ThreadId_t));
    #ifdef WINDOWS
       m_event = CreateEvent(NULL,FALSE,FALSE,NULL);
       if( !m_event )
       {
          m_bCreated = FALSE;
       }
    #else
       pthread_mutexattr_t mattr;

       pthread_mutexattr_init(&mattr);
       pthread_mutex_init(&m_lock,&mattr);
       pthread_cond_init(&m_ready,NULL);

    #endif
    }

    CEventClass::~CEventClass(void)
    {
    #ifdef WINDOWS
       CloseHandle(m_event);
    #else
       pthread_cond_destroy(&m_ready);
       pthread_mutex_destroy(&m_lock);
    #endif
    }


    /**
     *
     * Set
     * 设置某一事件为有信号状态
     *
     **/
    void
    CEventClass::Set()
    {
    #ifdef WINDOWS
       SetEvent(m_event);
    #else
       pthread_cond_signal(&m_ready);
    #endif
    }

    /**
     *
     * Wait
     * 等待一个事件对象为有信号状态,必须在同一线程中与Reset调用成对使用。
     *
     **/
    BOOL
    CEventClass::Wait()
    {

       try
       {
          ThreadId_t id = CThread::ThreadId();
          if( CThread::ThreadIdsEqual(&id,&m_owner) )
          {
             throw "/n/t invalid Wait call, Wait can not be called more
                    than once"
                "/n/t without a corresponding call to Reset!/n";
          }
          ThreadId_t zero;
          memset(&zero,0,sizeof(ThreadId_t));

          if( memcmp(&zero,&m_owner,sizeof(ThreadId_t)) != 0 )
          {
             throw "/n/t another thread is already waiting on this event!/n";
          }

          m_owner = CThread::ThreadId();
    #ifdef WINDOWS
          if( WaitForSingleObject(m_event,INFINITE) != WAIT_OBJECT_0 )
          {
             return FALSE;
          }
    #else
          pthread_mutex_lock(&m_lock);
          pthread_cond_wait(&m_ready,&m_lock);
          return TRUE;
    #endif
       }
       catch( char *psz )
       {
    #ifdef WINDOWS
          MessageBoxA(NULL,&psz[2],"Fatal exception CEventClass::Wait",
                      MB_ICONHAND);
          exit(-1);
    #else
          cerr << "Fatal exception CEventClass::Wait: " << psz;
    #endif

       }
       return TRUE;
    }

    /**
     *
     * Reset
     * 复位一个事件标志为无信号状态,必须在同一线程中与前面的Wait成对使用。
     *
     **/
    void
    CEventClass::Reset()
    {
       try
       {
          ThreadId_t id = CThread::ThreadId();
          if( !CThread::ThreadIdsEqual(&id,&m_owner) )
          {
             throw "/n/t unbalanced call to Reset, Reset must be called
                    from/n"
                "/n/t the same Wait-Reset pair!/n";
          }

          memset(&m_owner,0,sizeof(ThreadId_t));

    #ifndef WINDOWS
          pthread_mutex_unlock(&m_lock);
    #endif
       }
       catch( char *psz )
       {
    #ifdef WINDOWS
          MessageBoxA(NULL,&psz[2],"Fatal exception CEventClass::Reset",
                      MB_ICONHAND);
          exit(-1);
    #else
          cerr << "Fatal exception CEventClass::Reset: " << psz;
    #endif

       }
    }


    <!-- @page { margin: 2cm } P { margin-bottom: 0.21cm } -->

    函数

    描述

    void Set()

    设置一个事件状态为有信号,通知阻塞的线程。

    BOOL Wait()

    把调用线程置于阻塞状态,直到事件状态为有信号。成功返回TRUE,否则返回FALSE

    void Reset()

    把一个有信号事件重置为无信号状态。




        接收信号的线程使用事件对象的例子:


    CEventClass event;
       .
       .
    //线程代码
       .
       .
       while(bContinueRunning)
       {

          event.Wait();     // 等待事件发生

          // 执行某些任务
           .
           .
          event.Reset();    // 重置事件为无信号状态
       }
       .
       .


        向另一线程发信号时使用事件对象的例子:


    CEventClass event;
       .
       .
    // 改动了一些数据
       .
       .
       event.Set();    // 通知线程一个事件已发生,设置事件为有信号状态。
       .
       .


        CTask类及非特定的线程
        在许多线程编程的示例中,线程处理的数据一般都放在由mutex保护的全局变量中,操纵数据的指令也在集成进线程函数中,我们把这种形式的的线程称为特定异步线程(SAT);理想上来说,数据及对应的处理数据的功能,都应封装进同一对象,我们把这种形式的线程称为同种异步线程(HAT)。在HAT模式下,线程不是特定的,举例来说,HAT中就没有打印线程及I/O线程,取而代之的是,单一线程能执行这两种任务,因为任务是彻底作为对象来实现的,那就是说,它们包含了数据及必要的功能。CTask类就是一个采用HAT线程模式的基类。


    typedef enum {
       TaskStatusNotSubmitted,
       TaskStatusWaitingOnQueue,
       TaskStatusBeingProcessed,
       TaskStatusCompleted } TaskStatus_t;

    class CTask
    {
    private:
       CMutexClass m_mutex;
       TaskStatus_t m_state;
       ThreadId_t m_dwThread;
    public:
       void SetTaskStatus(TaskStatus_t state)
       {
          m_mutex.Lock();
             m_state=state;
          m_mutex.Unlock();
       }

       void SetId(ThreadId_t *pid)
       {
          memcpy(&m_dwThread,pid,sizeof(ThreadId_t));
       }

       /**
        *
        * Wait
        * 等待任务完成,或timeoutSeconds秒
        *
       **/
       BOOL Wait(int timeoutSeconds)
       {
          timeoutSeconds = timeoutSeconds * 1000;
          if( Status() != TaskStatusCompleted &&
              timeoutSeconds > 0 )
          {
             Sleep(100);
             timeoutSeconds = timeoutSeconds - 100;
          }
          if( Status() == TaskStatusCompleted ) return TRUE;
          return FALSE;
       }

       /**
        *
        * 在此返回任务的当前状态
        *
        **/
       TaskStatus_t Status()
       {
          TaskStatus_t state ;

          m_mutex.Lock();
            state = m_state;
          m_mutex.Unlock();
          return state;
       }

       void Thread(ThreadId_t *pId)
       {
          memcpy(pId,&m_dwThread,sizeof(ThreadId_t));
       }

       CTask(){m_state=TaskStatusNotSubmitted;
               memset(&m_dwThread,sizeof(ThreadId_t),0); }
       ~CTask(){}
       virtual BOOL Task()=0;
    };


    <!-- @page { margin: 2cm } P { margin-bottom: 0.21cm } -->

    函数

    描述

    m_mutex

    Mutex类型的同步对象

    virtual BOOL Task()

    由一CThread对象调用执行相应任务

    TaskStatus_t Status()

    确定任务状态:TaskStatusNotSubmittedTaskStatusWaitingOnQueueTaskStatusBeingProcessedTaskStatusCompleted

    void Thread(ThreadId_t *pid)

    返回处理线程的线程ID

    BOOL Wait(int iTimeInSeconds)

    将一个调用线程置于等待状态,直到任务结束或iTimeInSeconds时间到。如果一个任务在iTimeInSeconds时间内未完成,将返回FALSE,否则返回TRUE




        在此没有定义CThread类,定不定义它与理解其与CTask对象怎样交互并无关系,下表列出了两者是如何交互的:


    处理CTask对象的步骤:

    一个CTask对象被传递给CThread对象以便进行处理。
    CThread对象将CTask对象放置于一个先来先服务队列中。
    CThread对象将CTask对象状态设为 TaskStatusWaitingOnQueue。
    CThread对象将CTask对象弹出等待队列。
    CThread对象将CTask对象状态修改为 TaskStatusBeingProcessed。
    CThread对象调用CTask对象的成员函数task执行相应任务。
    CThread对象将CTask对象状态修改为 TaskStateCompleted。


        下面是CThread类的函数列表:


    <!-- @page { margin: 2cm } P { margin-bottom: 0.21cm } -->

    函数

    描述

    void CThread()

    构造函数,初始化对象数据并启动线程。

    void ~CThread()

    析构函数,结束线程并释放资源。

    BOOL Event(LPVOID lpvData)

    放置一数据块在事件堆栈或队列中,并通知对象线程要处理的数据已经准备好了。

    BOOL Event(CTask *pTask)

    放置一CTask对象在事件堆栈或队列中,并通知对象线程任务正待被执行。

    int GetEventsPending()

    返回事件堆栈中等待的事件数。

    ThreadId_t GetId()

    返回对象线程ID

    DWORD GetErrorFlags()

    返回对象的错误标志。如果没有错误,会返回一个零值(NO_ERRORS);如果有错误,就会设置以下的标志位:MUTEX_CREATION(未创建mutex对象)、EVENT_CREATION(未创建事件对象)、THREAD_CREATION(未创建对象的线程)、ILLEGAL_USE_OF_EVENT(非法使用Event成员函数)。

    BOOL PingThread(DWORD dwTimeoutMilli)

    判断对象的线程是否在运行。如果在运行返回TRUE,否则返回FALSE,超时以秒为单位。

    SetPriority(DWORD dwPriority)

    设置线程的优先级,只在Windows平台上有效。

    BOOL Start()

    开始对象线程。

    BOOL Stop()

    停止对象线程。

    void SetIdle(DWORD dwIdle)

    以毫秒为单位修改线程的空闲时间。

    SetThreadType(ThreadType_t typ,DWORD dwIdle)

    修改线程类型为ThreadTypeEventDrivenThreadTypeIntervalDriven

    m_mutex

    用于同步的mutex对象,参见CMutexClass

    ThreadState_t ThreadState()

    返回线程状态:ThreadStateBusy(线程正在处理一个事件)、ThreadStateWaiting(线程正在等等一个新事件)、ThreadStateDown(线程未运行)、ThreadStateShutingDown(线程正在关闭)。





        了解了支撑类之后,下面来看一下主类CThread,即最主要的工作线程类。CThread支持两种类型的线程:事件驱动的及间隔驱动的。事件驱动的线程是一种阻塞于事件对象、处于等待状态的线程,直至事件对象的状态由无信号转为有信号,当另一个线程把某项任务放入CThread对象的队列中时,一个新的事件就发生了,且会通过设置事件对象为有信号来通知对象线程。一旦有信号之后,线程被唤醒并从事件队列中弹出相应的任务,直至队列为空。
        CThread对象为每个任务都调用OnTask成员函数,任务以先来先服务(FDFS)的顺序被执行,因此,第一个放入CThread对象队列中的任务会首先被执行,接着是第二个,如此下去。此时,mutex对象起着队列访问的同步作用,可在线程正在执行某项任务时,把另一个事件放入到队列中来。一旦队列为空,线程则重置事件对象为无信号状态并返回等待下一个事件对象。CThread类支持两种类型的事件驱动线程:特定的及非特定的,参见CTask。
    为实现一个特定的线程,必须从CThread类派生出一个新类,这个派生的类应包括OnTask的一个重定义的实现,以处理对象数据类型。


    #include "Thread.h"
    class CIncrementThread : public CThread
    {
    public:
       int counter;

       virtual BOOL OnTask( LPVOID lpv )
       {
          ThreadId_t id;

          GetId(&id);
          if( lpv )
          {
             int *pInt = (int *)lpv;

             //在此不能使用cout,输出会因为线程的原因而有所间断
             printf("/tthread(%ld, counter+%d=%d, counter incremented/n",
                    id,*pInt,(counter+=*pInt));
          }
          return TRUE;
       }

       virtual BOOL OnTask()
       {
          ThreadId_t id;

          GetId(&id);
          //在此不能使用cout,输出会因为线程的原因而有所间断
          m_mutex.Lock();    //保护计数变量
             printf("/tthread(%ld, counter++= %d, counter incremented)/n",
                    id,(++counter));
          m_mutex.Unlock();


          return TRUE;
       }

          int GetValue()
          {
             int counterValue = 0;
             m_mutex.Lock();    //保护计数变量
                counterValue = counter;
             m_mutex.Unlock();
             return counter;
          }

          void Reset()
          {
             m_mutex.Lock();
                 counter = 0;
              m_mutex.Unlock();
          }

       CIncrementThread(){counter=0;}
       ~CIncrementThread(){}
    };

    int main( int argc,
              char *argv[])
    {
       //分配对象并开始线程
       CIncrementThread MyThread;
       int two=2;

       while( MyThread.GetValue() < 20 )
       {
          MyThread.Event();    //增量加1
          Sleep(100);          //暂停根线程100毫秒
       }

       MyThread.Reset();
       while( MyThread.GetValue() < 40 )
       {
          MyThread.Event(&two);
          Sleep(100);
       }
    }


    OUTPUT:
            thread(5220, counter++= 1, counter incremented)
            thread(5220, counter++= 2, counter incremented)
            thread(5220, counter++= 3, counter incremented)
            thread(5220, counter++= 4, counter incremented)
            thread(5220, counter++= 5, counter incremented)
            thread(5220, counter++= 6, counter incremented)
            thread(5220, counter++= 7, counter incremented)
            thread(5220, counter++= 8, counter incremented)
            thread(5220, counter++= 9, counter incremented)
            thread(5220, counter++= 10, counter incremented)
            thread(5220, counter++= 11, counter incremented)
            thread(5220, counter++= 12, counter incremented)
            thread(5220, counter++= 13, counter incremented)
            thread(5220, counter++= 14, counter incremented)
            thread(5220, counter++= 15, counter incremented)
            thread(5220, counter++= 16, counter incremented)
            thread(5220, counter++= 17, counter incremented)
            thread(5220, counter++= 18, counter incremented)
            thread(5220, counter++= 19, counter incremented)
            thread(5220, counter++= 20, counter incremented)
            thread(5220, counter+2=2, counter incremented
            thread(5220, counter+2=4, counter incremented
            thread(5220, counter+2=6, counter incremented
            thread(5220, counter+2=8, counter incremented
            thread(5220, counter+2=10, counter incremented
            thread(5220, counter+2=12, counter incremented
            thread(5220, counter+2=14, counter incremented
            thread(5220, counter+2=16, counter incremented
            thread(5220, counter+2=18, counter incremented
            thread(5220, counter+2=20, counter incremented
            thread(5220, counter+2=22, counter incremented
            thread(5220, counter+2=24, counter incremented
            thread(5220, counter+2=26, counter incremented
            thread(5220, counter+2=28, counter incremented
            thread(5220, counter+2=30, counter incremented
            thread(5220, counter+2=32, counter incremented
            thread(5220, counter+2=34, counter incremented
            thread(5220, counter+2=36, counter incremented
            thread(5220, counter+2=38, counter incremented
            thread(5220, counter+2=40, counter incremented


    在上面的例子中,从CThread类中派生了一个CIncrementThread类,且重定义了OnTask()及OnTask(LPVOID)虚成员函数。在OnTask()的实现中,添加了一个对象计数变量,而OnTask的另一个成员函数接受一个指向整型值的指针,并将指针值添加到计数成员变量中。这个例子演示了一个线程可处理的两类事件,又因为计数变量可能会被不止一个线程访问,所以用了CThread::m_mutex对象来保证访问的独占性。
    另外,在此的HAT是由CThread及CTask两者来实现的。


    #include "Thread.h"
    class CTaskIncrementer: public CTask
    {
    private:
       int counter;
       int incr;
    public:
       void SetIncr(int iValue)
       {
          m_mutex.Lock();
             incr = iValue;
          m_mutex.Unlock();
       }

       int GetIncrementValue()
       {
          int incrValue;
          m_mutex.Lock();
             incrValue=incr;
          m_mutex.Unlock();
             return incrValue;
       }

       int GetValue()
       {
          int counterValue = 0;
          m_mutex.Lock();    //保护计数变量
             counterValue = counter;
          m_mutex.Unlock();
             return counter;
       }

       BOOL Task()
       {
          ThreadId_t id;

          Thread(&id);

          m_mutex.Lock();
             printf("/tthread(%ld, counter+%d=%d, counter incremented/n",
                    id,incr,(counter+=incr));
          m_mutex.Unlock();
             return TRUE;
       }
       CTaskIncrementer(){counter=0;}
       ~CTaskIncrementer(){}
    };

    int
    main(int argc,
       char *argv[])
    {
       CTaskIncrementer incr;
       CThread thr;

       incr.SetIncr(2);
       while( incr.GetValue() < 40 ) thr.Event(&incr);
    }

    OUTPUT:
           thread(5700, counter+2=2, counter incremented
           thread(5700, counter+2=4, counter incremented
           thread(5700, counter+2=6, counter incremented
           thread(5700, counter+2=8, counter incremented
           thread(5700, counter+2=10, counter incremented
           thread(5700, counter+2=12, counter incremented
           thread(5700, counter+2=14, counter incremented
           thread(5700, counter+2=16, counter incremented
           thread(5700, counter+2=18, counter incremented
           thread(5700, counter+2=20, counter incremented
           thread(5700, counter+2=22, counter incremented
           thread(5700, counter+2=24, counter incremented
           thread(5700, counter+2=26, counter incremented
           thread(5700, counter+2=28, counter incremented
           thread(5700, counter+2=30, counter incremented
           thread(5700, counter+2=32, counter incremented
           thread(5700, counter+2=34, counter incremented
           thread(5700, counter+2=36, counter incremented
           thread(5700, counter+2=38, counter incremented
           thread(5700, counter+2=40, counter incremented


    间隔驱动的线程是一种在预先定义的间隔时间上被唤醒的线程,它会检查所在环境是否发生了变化,并处理这些变化,之后休眠等待下一个间隔时间,接着再唤醒做同样的事。要实现一个间隔驱动的线程,需派生一个CThread类并重定义OnTask(LPVOID)。一旦线程实例化后,就可以用ThreadTypeIntervalDriven参数来调用SetThreadType成员函数,设置好以毫秒计的间隔。


    #include "Thread.h"

    class CIncrementThread : public CThread
    {
    public:
       int counter;

       virtual BOOL OnTask()
       {
          ThreadId_t id;

          GetId(&id);
          //在此不能使用cout,输出会因为线程的原因而有所间断
          m_mutex.Lock();    //保护计数变量
             printf("/tthread(%ld, counter++= %d, counter incremented)/n",
                    id,(++counter));
          m_mutex.Unlock();


          return TRUE;
       }

       int GetValue()
       {
          int counterValue = 0;
          m_mutex.Lock();    //保护计数变量
             counterValue = counter;
          m_mutex.Unlock();
          return counter;
       }

       void Reset()
            {
                m_mutex.Lock();
                   counter = 0;
                m_mutex.Unlock();
            }

       CIncrementThread(){counter=0;}
       ~CIncrementThread(){}
    };

    int
    main( int argc,
        char *argv[] )
    {
       CIncrementThread thr;

       thr->SetThreadType(ThreadTypeIntervalDriven,100);
       Sleep(500);

    }

    OUTPUT:
            thread(6104, counter++= 12, counter incremented)
            thread(6104, counter++= 13, counter incremented)
            thread(6104, counter++= 14, counter incremented)
            thread(6104, counter++= 15, counter incremented)
            thread(6104, counter++= 16, counter incremented)


        结论
    以上就是一个全功能的线程对象,且在Linux上做过测试,但没有在SunOS及其他Unix平台上测试过,不过应该也没问题。当在Windows上编译时,一定要代码生成选项上指定/Mt或/Mtd,表明你的程序是一个多线程程序,而下面则是Linux上的make文件。


    CC=g++
    LIBS=-lpthread -lrt
    CFLAGS=-DSUNOS -DNANO_SECOND_SLEEP

    OBJS=Thread.cpp EventClass.cpp MutexClass.cpp main.cpp


    EXECS = thread

    all: $(EXECS)

    thread: $(OBJS)
        $(CC) $(CFLAGS) -o thread $(OBJS) $(LIBS)


    clean:; rm -f *.o $(EXECS)

    展开全文
  • "least_money_to_use_bonus" => 1000, // 抵扣条件,满xx元(这里以分为单位)可用。 "max_reduce_bonus" => 50 // 抵扣条件,单笔最多使用xx积分。 ], 开卡后没有增加积分的原因是激活会员卡的方式,如果设置...

    ##设置初始积分,开卡后并没有增加积分?

    // 关闭自动开卡
    "auto_activate" => false,
    // 这是设置积分规则部分参数
    "bonus_rule" => [
        "cost_money_unit" => 1,              // 消费金额。以分为单位。  
        "increase_bonus" => 1,               // 对应增加的积分。
        "max_increase_bonus" => 200,         // 用户单次可获取的积分上限。
        "init_increase_bonus" => 10,         // 初始设置积分。
        "cost_bonus_unit" => 100,            // 每使用5积分。
        "reduce_money" => 100,               // 抵扣xx元,(这里以分为单位)
        "least_money_to_use_bonus" => 1000,  // 抵扣条件,满xx元(这里以分为单位)可用。
        "max_reduce_bonus" => 50             // 抵扣条件,单笔最多使用xx积分。
    ],
    

    开卡后没有增加积分的原因是激活会员卡的方式,如果设置自动激活的话,开卡的积分并不会赠送。我用的是【一键激活】=》【普通一键激活】。有几个注意的点:

    • 填入了自动激活auto_activate字段,激活链接activate_url和一键开卡接口设置都会失效;
    • 若同时传入了activate_url,则一键开卡接口设置会失效;
    • 建议开发者activate_url、auto_activate和wx_activate只填写一项;

    会员卡表面如何显示会员码?

    "pay_info" => [
    	"swipe_card" => [
            "is_swipe_card" => true
    	]
    ],
    

    积分、等级、优惠券如何自定义?

    // 最多支持三个
    "custom_field1" => [
    	"name_type" => "FIELD_NAME_TYPE_LEVEL", // 显示名称
    	"url" => "http://www.qq.com"            // 跳转链接
    ],
    "custom_field2" => [
    	"name_type" => "FIELD_NAME_TYPE_COUPON",
    	"url" => "http://www.baidu.com"
    ],
    

    普通一键开卡如何设置开发字段?

    1. 先使用开卡字段接口
    2. 在使用设置开卡字段接口,这两个接口是分开的
    展开全文
  • 这里能够提供更多的可供使用的操作符,但是其中的一些需要谨慎地使用,因为它们也许会比你期待的改变的更多。 “=”操作符 这个操作符简单分配一个值给一个变量。使用方法如下: TARGET = myapp 这将会设置...
  • 第四章 创建M2M平台 Apple、Google、亚马逊等经验告诉我们,利润增长是通过解决更多人在更多地方、更多情景的需求来实现。我们也学到了开发者是生态系统的关键成员,他们角色是发现新用户案例和情景。下一步是创建一...
  • 关于创建Android Library所需要知道的一切Android 库(Library)在结构上与 Android 应用模块相同。应用模块所可以包含的东西,在库中都允许存在,包括代码文件、资源文件和manifest文件等。应用模块编译后生成的是...
  • 微信会员卡创建

    千次阅读 2019-03-02 15:43:05
    正式开发前,开发者需要去公众平台开通微信卡券功能,添加功能插件、开通卡券功能即可。当然,如果没有公众号或者其他限制条件,也可以申请测试账号进行进口开发和调试,文末会附上申请地址。 调用接口创建会员卡...
  • 从更广泛意义上来说,物联网平台是一套集成的工具和服务,可帮助开发人员创建应用程序。 让我们想想Uber是如何运作的。Uber在您使用该应用寻找周围出租车的时才起作用,在这种情境下,优步就是利用物联网和机器学习...
  • uni-app 已将常用的组件、JS API 封装到框架中,开发者按照 uni-app 规范开发即可保证多平台兼容,大部分业务均可直接满足。 但每个平台有自己的一些特性,因此会存在一些无法跨平台的情况。 大量写 if else,会造成...
  • 同时,合适的物联网平台可以通过多种方式为您服务,但首先,我们需要了解其含义。 设备充当信息的发射器。它们会告诉公司您的行为、健康状况(想想FitBit)以及您的喜好,这些设备都属于物联网范畴。虽然公司能够挖掘...
  • Chromium为视频标签创建播放器的过程分析

    万次阅读 热门讨论 2016-08-15 00:59:33
    WebKit是平台无关的,而播放器实现是平台相关的。因此,WebKit并没有自己实现播放器,而仅仅是创建一个播放器接口。通过这个播放器接口,可以使用平台提供的播放器来播放视频的内容。这就简化了Chromium对视频标签的...
  • 问题描述:为什么在MySQL数据库中不能创建外键,尝试了很多次,既没有报错,也没有显示创建成功,真实奇了怪,这是为什么呢? 问题解决:通过查找资料,每次在MySQL数据库中创建表时默认的情况是这样的: 从图中...
  • 在硬件加速渲染条件下,这个输出有可能是一个OpenGL纹理,也有可能是一系列需要进一步进行绘制的OpenGL纹理,取决于Render进程使用直接渲染器还是委托渲染器。本文接下来就对网页的绘图表面的创建过程进行详细分析。
  • 大数据web平台有时需要查看不同指标按不同类型和筛选条件来出结果, 且系统做不到实时出结果, 故需要在web系统中选择指标和条件创建任务进行非实时计算, 一段时间后计算结果写入结果表, 访问页面并查看处理结果. ...
  • 阿里云服务器如何创建安全组?

    千次阅读 2019-12-12 09:49:11
    前提条件 如果要创建安全组,首先得有一台服务器,关于服务器如何选择、配置挑选等 请参阅云服务器实例规格文档 背景信息 每台ECS实例必须至少属于一个安全组。在您创建ECS实例时,如果您还未创建过安全组,阿里云会...
  • 以太坊:创建 ERC-20 token

    万次阅读 2019-05-10 10:10:03
    什么是ERC20 可以把ERC20简单理解成以太坊上的一个代币协议,所有基于以太坊开发的代币合约都遵守这个协议。遵守这些协议的代币我们可以认为是标准化的代币,而标准化带来的好处是兼容性好。这些标准化的代币可以被...
  • SQL 创建索引,语法

    千次阅读 2014-06-07 16:10:16
    主键是唯一的,所以创建了一个主键的同时,也就这个字段创建了一个唯一的索引。SQL SERVER将主键默认定义为聚集索引,事实上,索引是否唯一与是否聚集是不相关的,聚集索引可以是唯一索引,也可以是非唯一索引; ...
  • 创建一个cab文件所需要INF文件

    千次阅读 2007-12-03 09:36:00
    INF文件是一个文本文件,指定运行控件所需要下载和注册的组件(比如DLL或其它OCX)。一个INF文件描述了CAB压缩包中所有必须的文件。在缺省情况下,若客户端系统中有压缩包中的文件,则版本号相同的文件不被下载。一个...
  • nova创建虚机流程源码分析 openstack

    万次阅读 2017-04-19 11:21:47
    今天跟大家分享openstack中利用nova创建虚机时的源码流程,以便更好的理解openstack云平台实现,也有助于故障定位。
  • 教你如何一步步创建ERC20代币

    万次阅读 2018-03-16 23:44:26
    看这篇文章需要对以太坊,智能合约,代币等概念有基本的了解。 什么是ERC20 可以把ERC20简单理解成以太坊上的一个代币协议,所有基于以太坊开发的代币合约都遵守这个协议。遵守这些协议的代币我们可以认为是标准...
  • kafka只让Producer自动创建Topic背景操作后记 背景     最近我们要做从mysql 到大数据平台的数据流转,定下的方案是maxwell同步binlog到kafka中,再由flink消费kafka的数据写往kudu里,最后利用...
  • 再谈OpenJWeb快速开发平台商业价值

    千次阅读 2008-06-07 15:42:00
    因为此平台提供了各种功能创建向导,用户可以完全通过平台的功能创建向导来创建自己的需要的业务功能模块,这使得在没有软件开发人员的参与的情况下,用户仍然可以根据业务需要来定制一些简单的功能。二、 OpenJWeb...
  • 6.1、创建表 6.1.1、创建表的语法形式 CREATE TABLE 表名 ( 属性名 数据类型 [完整性约束条件], 属性名 数据类型 [完整性约束条件], ...... 属性名 数据类型 );   完整性约束条件表: PRIMARYKEY
  • Android 创建与解析XML(一)—— 概述

    万次阅读 多人点赞 2012-04-25 12:49:39
    XML,相关有DOM、SAX、JDOM、DOM4J、Xerces、JAXP等一堆概念,但是很多人总是会弄混他们之间的关系,这对我们理解XML文件的创建和解析很不利。要挑选一个适合在Android平台上使用的XML解析方案,我们还是得
  • 2018.5.28创建新的学习环境本教程将介绍创建 Unity 环境的过程。Unity 环境是用 Unity 引擎...这个球还要学习避免从平台上掉落。概述在 Unity 项目中使用 ML-Agents 涉及以下基本步骤:创建一个容纳 agent 的环境...
  • Telegram之创建机器人

    万次阅读 2020-01-19 08:18:21
    1、Telegram创建机器人Bot 第一步: 登录Telegram,并找到@BotFather,使用/new bot指令,并按照指示为你的Bot取个昵称以及用户名(Bot的用户名必需以bot结尾)。此时BotFather会给你一个非常重要的东西——Bot ...
  • 前面介绍了四种创建、解析XML的方式:0、 Android 创建与解析XML(一)—— 概述1、 Android 创建与解析XML(二)—— Dom方式2、 Android 创建与解析XML(三)—— Sax方式3、 Android 创建与解析XML(四)—— ...
  • oracle临时表的创建

    千次阅读 2019-05-17 22:44:23
    临时表的特点,什么时候用 前段时间,新公司的面试官问了一个问题,临时表的作用,以前我们用缓存中间数据时候,都是自己建一个临时表。其实oracle本身在这方面就已经考虑很全了,除非有些高级应用,我再考虑自己...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 250,073
精华内容 100,029
关键字:

创建平台需要什么条件