CN112363804B - Blockchain JVM application method, device and storage medium - Google Patents
Blockchain JVM application method, device and storage medium Download PDFInfo
- Publication number
- CN112363804B CN112363804B CN202011279724.6A CN202011279724A CN112363804B CN 112363804 B CN112363804 B CN 112363804B CN 202011279724 A CN202011279724 A CN 202011279724A CN 112363804 B CN112363804 B CN 112363804B
- Authority
- CN
- China
- Prior art keywords
- contract
- query
- jvm
- thread
- loading
- Prior art date
- Legal status (The legal status is an assumption and is not a legal conclusion. Google has not performed a legal analysis and makes no representation as to the accuracy of the status listed.)
- Active
Links
- 238000000034 method Methods 0.000 title claims abstract description 52
- 238000011068 loading method Methods 0.000 claims abstract description 58
- 230000004044 response Effects 0.000 claims abstract description 11
- 230000000903 blocking effect Effects 0.000 claims abstract description 4
- 238000004590 computer program Methods 0.000 claims description 9
- 238000010586 diagram Methods 0.000 description 6
- 238000004891 communication Methods 0.000 description 4
- 230000006870 function Effects 0.000 description 4
- 230000008569 process Effects 0.000 description 3
- 230000007246 mechanism Effects 0.000 description 2
- 230000007812 deficiency Effects 0.000 description 1
- 238000005516 engineering process Methods 0.000 description 1
- 239000004973 liquid crystal related substance Substances 0.000 description 1
- 230000003287 optical effect Effects 0.000 description 1
- 239000004065 semiconductor Substances 0.000 description 1
- 230000001960 triggered effect Effects 0.000 description 1
Classifications
-
- G—PHYSICS
- G06—COMPUTING; CALCULATING OR COUNTING
- G06F—ELECTRIC DIGITAL DATA PROCESSING
- G06F9/00—Arrangements for program control, e.g. control units
- G06F9/06—Arrangements for program control, e.g. control units using stored programs, i.e. using an internal store of processing equipment to receive or retain programs
- G06F9/44—Arrangements for executing specific programs
- G06F9/455—Emulation; Interpretation; Software simulation, e.g. virtualisation or emulation of application or operating system execution engines
- G06F9/45533—Hypervisors; Virtual machine monitors
- G06F9/45558—Hypervisor-specific management and integration aspects
-
- G—PHYSICS
- G06—COMPUTING; CALCULATING OR COUNTING
- G06F—ELECTRIC DIGITAL DATA PROCESSING
- G06F9/00—Arrangements for program control, e.g. control units
- G06F9/06—Arrangements for program control, e.g. control units using stored programs, i.e. using an internal store of processing equipment to receive or retain programs
- G06F9/44—Arrangements for executing specific programs
- G06F9/445—Program loading or initiating
- G06F9/44521—Dynamic linking or loading; Link editing at or after load time, e.g. Java class loading
-
- G—PHYSICS
- G06—COMPUTING; CALCULATING OR COUNTING
- G06F—ELECTRIC DIGITAL DATA PROCESSING
- G06F9/00—Arrangements for program control, e.g. control units
- G06F9/06—Arrangements for program control, e.g. control units using stored programs, i.e. using an internal store of processing equipment to receive or retain programs
- G06F9/46—Multiprogramming arrangements
- G06F9/54—Interprogram communication
- G06F9/544—Buffers; Shared memory; Pipes
-
- G—PHYSICS
- G06—COMPUTING; CALCULATING OR COUNTING
- G06Q—INFORMATION AND COMMUNICATION TECHNOLOGY [ICT] SPECIALLY ADAPTED FOR ADMINISTRATIVE, COMMERCIAL, FINANCIAL, MANAGERIAL OR SUPERVISORY PURPOSES; SYSTEMS OR METHODS SPECIALLY ADAPTED FOR ADMINISTRATIVE, COMMERCIAL, FINANCIAL, MANAGERIAL OR SUPERVISORY PURPOSES, NOT OTHERWISE PROVIDED FOR
- G06Q40/00—Finance; Insurance; Tax strategies; Processing of corporate or income taxes
- G06Q40/04—Trading; Exchange, e.g. stocks, commodities, derivatives or currency exchange
-
- G—PHYSICS
- G06—COMPUTING; CALCULATING OR COUNTING
- G06F—ELECTRIC DIGITAL DATA PROCESSING
- G06F9/00—Arrangements for program control, e.g. control units
- G06F9/06—Arrangements for program control, e.g. control units using stored programs, i.e. using an internal store of processing equipment to receive or retain programs
- G06F9/44—Arrangements for executing specific programs
- G06F9/455—Emulation; Interpretation; Software simulation, e.g. virtualisation or emulation of application or operating system execution engines
- G06F9/45533—Hypervisors; Virtual machine monitors
- G06F9/45558—Hypervisor-specific management and integration aspects
- G06F2009/45562—Creating, deleting, cloning virtual machine instances
-
- G—PHYSICS
- G06—COMPUTING; CALCULATING OR COUNTING
- G06F—ELECTRIC DIGITAL DATA PROCESSING
- G06F9/00—Arrangements for program control, e.g. control units
- G06F9/06—Arrangements for program control, e.g. control units using stored programs, i.e. using an internal store of processing equipment to receive or retain programs
- G06F9/44—Arrangements for executing specific programs
- G06F9/455—Emulation; Interpretation; Software simulation, e.g. virtualisation or emulation of application or operating system execution engines
- G06F9/45533—Hypervisors; Virtual machine monitors
- G06F9/45558—Hypervisor-specific management and integration aspects
- G06F2009/45595—Network integration; Enabling network access in virtual machine instances
-
- Y—GENERAL TAGGING OF NEW TECHNOLOGICAL DEVELOPMENTS; GENERAL TAGGING OF CROSS-SECTIONAL TECHNOLOGIES SPANNING OVER SEVERAL SECTIONS OF THE IPC; TECHNICAL SUBJECTS COVERED BY FORMER USPC CROSS-REFERENCE ART COLLECTIONS [XRACs] AND DIGESTS
- Y02—TECHNOLOGIES OR APPLICATIONS FOR MITIGATION OR ADAPTATION AGAINST CLIMATE CHANGE
- Y02D—CLIMATE CHANGE MITIGATION TECHNOLOGIES IN INFORMATION AND COMMUNICATION TECHNOLOGIES [ICT], I.E. INFORMATION AND COMMUNICATION TECHNOLOGIES AIMING AT THE REDUCTION OF THEIR OWN ENERGY USE
- Y02D10/00—Energy efficient computing, e.g. low power processors, power management or thermal management
Abstract
The invention provides a blockchain JVM application method, equipment and a storage medium, wherein the method comprises the following steps: a jvm execution thread and a jvm query thread are respectively created, and a secondary loading packet is loaded; transaction execution parameters for a first transaction are received in response to the jvm execution thread: blocking the first thread; invoking a contract loading method to determine whether a corresponding first contract was loaded: if not, loading a first contract and caching contract byte codes by a contract loading method, and executing a first transaction; if yes, executing a first transaction; returning to the first thread; in response to receiving a number of query requests, concurrent responses: invoking a contract loading method to determine whether a corresponding second contract was loaded: if not, loading a second contract and caching contract byte codes through a contract loading method, and creating a second thread by a jvm query thread to query through the second contract and return a query result; if so, the jvm query thread creates a third thread to query and return the query results. The invention realizes flexible loading of different intelligent contracts in the JVM.
Description
Technical Field
The application relates to the technical field of Internet, in particular to a blockchain JVM application method, a device and a storage medium.
Background
The intelligent contracts of the blockchain are required to be executed in virtual machines, and the current intelligent contracts virtual machines of the blockchain mainly adopt EVM. Since EVM is a new virtual machine, its security and friendliness of development language need to be improved, and programmers working on development of this language are not so much, development of intelligent contracts is limited.
A Java virtual machine (Java Virtual Machine, hereinafter abbreviated as JVM) is a virtual machine capable of running Java bytecodes, and is implemented as a stack structure machine. The first implementation version developed and implemented by Sun microsystems was part of a Java platform, and was able to run software programs written in Java language.
The Java virtual machine has a perfect hardware architecture, such as a processor, a stack, a register and the like, and also has a corresponding instruction system. The JVM masks information about a specific operating system platform so that Java programs can run unmodified on a variety of platforms by only generating object code (bytecode) that runs on the Java virtual machine.
In existing JVM mechanisms, the creation of a JVM requires setting a class-path (address of the jar packet, e.g.,% java_home% \lib. Jar;%java_home% \lib tools. Jar), which cannot be modified after the JVM is created.
For the scheme of applying the JVM in the blockchain system, after the smart contracts are published in the jar packet form, the existing JVM mechanism has the problem that different smart contracts cannot be loaded because the class-path cannot be modified.
Disclosure of Invention
In view of the foregoing deficiencies or inadequacies of the prior art, it would be desirable to provide a blockchain JVM application method, apparatus and storage medium that can flexibly load different smart contracts in a JVM to perform transactions or queries.
In a first aspect, the present invention provides a blockchain JVM application method applicable to a blockchain node, in which a JVM is configured with a custom secondary loading packet, the method comprising:
a jvm execution thread and a jvm query thread are respectively created, and a secondary loading packet is loaded;
in response to the jvm execution thread receiving a transaction execution parameter for a first transaction sent by a first thread of the blockchain execution module:
blocking the first thread;
jvm execution thread calls the contract loading method of the secondary loading packet to judge whether to load and buffer the first contract corresponding to the first transaction according to the transaction execution parameters:
if not, loading a first contract through a contract loading method, caching byte codes of the first contract, and executing a first transaction through the first contract;
if yes, executing a first transaction through a first contract;
returning to the first thread;
in response to receiving a number of query requests, each query request is responded to concurrently by:
invoking a contract loading method to judge whether the corresponding second contract is loaded and cached according to the first query request:
if not, loading a second contract through a contract loading method, caching byte codes of the second contract, creating a second thread by a jvm query thread, executing the query requested by the first query request through the second contract by the second thread, and returning a query result;
if so, the jvm query thread creates a third thread that executes the query requested by the first query request via the second contract and returns the query result.
In a second aspect, the present invention also provides an apparatus comprising one or more processors and a memory, wherein the memory contains instructions executable by the one or more processors to cause the one or more processors to perform a blockchain JVM application method provided in accordance with embodiments of the present invention.
In a third aspect, the present invention also provides a storage medium storing a computer program, where the computer program causes a computer to execute the blockchain JVM application method provided according to the embodiments of the present invention.
According to the blockchain JVM application method, the device and the storage medium provided by the embodiments of the invention, a secondary loading package with a contract loading method is configured in a self-defined manner in JVM, and the secondary loading package is loaded when JVM is created, so that the contract loading method of the secondary loading package can be called to flexibly load intelligent contracts when transaction execution parameters or inquiry requests of transactions to be executed are received, and different intelligent contracts are flexibly loaded in the JVM to execute transactions or inquiries; in addition, the byte codes of the loaded contracts are cached, so that the repeated loading of the JVM on the same contract is avoided, the average time for executing each transaction by the system is reduced, and the TPS of the system is improved;
according to the blockchain JVM application method, the device and the storage medium provided by some embodiments of the invention, the development difficulty of developing java intelligent contracts by developers is further reduced by configuring the blockchain interface of the native type in the java compiler of the blockchain node.
Drawings
Other features, objects and advantages of the present application will become more apparent upon reading of the detailed description of non-limiting embodiments, made with reference to the following drawings, in which:
FIG. 1 is a flowchart of a blockchain JVM application method according to an embodiment of the present invention.
Fig. 2 is a schematic structural diagram of an apparatus according to an embodiment of the present invention.
Detailed Description
The present application is described in further detail below with reference to the drawings and examples. It is to be understood that the specific embodiments described herein are merely illustrative of the invention and are not limiting of the invention. It should be noted that, for convenience of description, only the portions related to the invention are shown in the drawings.
It should be noted that, in the case of no conflict, the embodiments and features in the embodiments may be combined with each other. The present application will be described in detail below with reference to the accompanying drawings in conjunction with embodiments.
FIG. 1 is a flowchart of a blockchain JVM application method according to an embodiment of the present invention.
As shown in fig. 1, in this embodiment, the present invention provides a blockchain JVM application method applicable to a blockchain node, in which a JVM is configured with a custom secondary loading packet, the method includes:
s11: a jvm execution thread and a jvm query thread are respectively created, and a secondary loading packet is loaded;
in response to the jvm execution thread receiving a transaction execution parameter for a first transaction sent by a first thread of the blockchain execution module:
s121: blocking the first thread;
s122: jvm execution thread calls the contract loading method of the secondary loading packet to judge whether to load and buffer the first contract corresponding to the first transaction according to the transaction execution parameters:
if not, then step S123 is performed: loading a first contract through a contract loading method, caching byte codes of the first contract, and executing a first transaction through the first contract;
if yes, step S124 is executed: executing the first transaction through the first contract;
s125: returning to the first thread;
in response to receiving a number of query requests, each query request is responded to concurrently by:
s131: invoking a contract loading method to judge whether the corresponding second contract is loaded and cached according to the first query request:
if not, then step S132 is performed: loading a second contract through a contract loading method, caching byte codes of the second contract, creating a second thread by a jvm query thread, executing the query requested by the first query request through the second contract by the second thread, and returning a query result;
if yes, step S133 is executed: the jvm query thread creates a third thread that executes the query requested by the first query request via the second contract and returns the query result.
The above method is exemplarily described below by taking the example that the blockchain node a executes a transaction and queries data through the JVM.
In this embodiment, the java compiler of each blockchain node is configured with a blockchain interface of a native type, and the blockchain interfaces include an account type interface, a status database type interface and a local database type interface. In other embodiments, other types of interfaces for obtaining blockchain random numbers, obtaining blockchain heights, and the like may be further configured.
In step S11, when initializing the local JVM, the blockchain node a creates JVM execution threads JVM _exec and JVM to Query the thread JVM _query, loads the secondary load packet loader.
When the thread a of the blockchain execution module sends the transaction execution parameter (condactname 0, para0, para1, …) of the transaction tx1 to be executed to the jvm execution thread jvm _exec, steps S121-S125 are triggered:
in step S121, in order to ensure that the transaction is performed sequentially (rather than in parallel), it is necessary to avoid that the thread a continues to send the transaction execution parameters of the next transaction tx2 before tx1 is performed, so that the thread a needs to be blocked;
in step S122, the JVM execution thread JVM _exec calls the contract loading method loadcontact of the secondary loading packet loader.jar, and determines whether the current JVM has loaded and cached the contract convectname 0 according to the contract name convectname 0 in the transaction execution parameter of tx 1:
if not, then step S123 is performed: loading a contract con-actname 0 through a contract loading method loadcontact, caching byte codes of the contract con-actname 0 in a memory, and analyzing and calling a transaction execution method of the contract con-actname 0 through a transaction execution method tx in a loader.
If yes, step S124 is executed: directly calling the cached transaction execution method of the contract actName0 to execute tx1;
in step S125, when tx1 is executed, thread a is returned; at this time, the thread a may send the transaction execution parameter of the next transaction tx2 to be executed to the jvm execution thread jvm _exec, thereby triggering steps S121-S125 again to continue executing tx2.
When node A receives multiple query requests Q1, Q2, Q3, responses Q1-Q3 are concurrently responded to by steps S131-S132/S133, taking response Q1 as an example:
in step S131, the contract loading method loadcontact is also called, and it is determined whether the current JVM has loaded and cached the contract connextname 1 according to the contract name connextname 1 in the query parameters (connextname 1, para10, para11, …) of Q1:
if not, then step S132 is performed:
loading a contract con-actName 1 by a loadContract method, and caching byte codes of the contract Name 1; the method comprises the steps of,
jvm querying a thread creation thread b;
the thread b calls a query method of the con name1 to query through a query method query in the loader;
if yes, step S133 is executed:
jvm querying a thread creation thread c;
and the thread c calls a query method of the con name1 through a query method query in the loader.
The specific process of responding to the query requests Q2 and Q3 is the same as the process of responding to Q1, and will not be described in detail.
The above examples take the example that the two-level loading package is configured with a transaction execution method, a query method and a contract loading method, and the above methods are exemplarily described; in other embodiments, the second-level load package in the above method may also be configured to include more methods for invoking other methods of the smart contract.
The embodiment of the invention has the advantages that the secondary loading package with the contract loading method is configured in a self-defined manner in JVM, and is loaded when JVM is created, so that the contract loading method of the secondary loading package can be called to flexibly load intelligent contracts when transaction execution parameters or query requests of transactions to be executed are received, and different intelligent contracts are flexibly loaded in the JVM to execute transactions or queries; in addition, by caching the byte codes of the loaded contracts, repeated loading of the JVM on the same contract is avoided, average time for executing each transaction by the system is reduced, and TPS of the system is improved.
Fig. 2 is a schematic structural diagram of an apparatus according to an embodiment of the present invention.
As shown in fig. 2, as another aspect, the present application also provides an apparatus 200 including one or more Central Processing Units (CPUs) 201, which can perform various appropriate actions and processes according to a program stored in a Read Only Memory (ROM) 202 or a program loaded from a storage portion 208 into a Random Access Memory (RAM) 203. In the RAM203, various programs and data required for the operation of the apparatus 200 are also stored. The CPU201, ROM202, and RAM203 are connected to each other through a bus 204. An input/output (I/O) interface 205 is also connected to bus 204.
The following components are connected to the I/O interface 205: an input section 206 including a keyboard, a mouse, and the like; an output portion 207 including a Cathode Ray Tube (CRT), a Liquid Crystal Display (LCD), and the like, and a speaker, and the like; a storage section 208 including a hard disk or the like; and a communication section 209 including a network interface card such as a LAN card, a modem, and the like. The communication section 209 performs communication processing via a network such as the internet. The drive 210 is also connected to the I/O interface 205 as needed. A removable medium 211 such as a magnetic disk, an optical disk, a magneto-optical disk, a semiconductor memory, or the like is installed on the drive 210 as needed, so that a computer program read out therefrom is installed into the storage section 208 as needed.
In particular, according to embodiments of the present disclosure, the method described in any of the above embodiments may be implemented as a computer software program. For example, embodiments of the present disclosure include a computer program product comprising a computer program tangibly embodied on a machine-readable medium, the computer program comprising program code for performing any of the methods described above. In such an embodiment, the computer program may be downloaded and installed from a network via the communication portion 209, and/or installed from the removable medium 211.
As yet another aspect, the present application also provides a computer-readable storage medium, which may be a computer-readable storage medium contained in the apparatus of the above-described embodiment; or may be a computer-readable storage medium, alone, that is not assembled into a device. The computer readable storage medium stores one or more programs for use by one or more processors to perform the methods described herein.
The flowcharts and block diagrams in the figures illustrate the architecture, functionality, and operation of possible implementations of systems, methods and computer program products according to various embodiments of the present invention. In this regard, each block in the flowchart or block diagrams may represent a module, segment, or portion of code, which comprises one or more executable instructions for implementing the specified logical function(s). It should also be noted that, in some alternative implementations, the functions noted in the block may occur out of the order noted in the figures. For example, two blocks shown in succession may, in fact, be executed substantially concurrently, or the blocks may sometimes be executed in the reverse order, depending upon the functionality involved. It will also be noted that each block of the block diagrams and/or flowchart illustration, and combinations of blocks in the block diagrams and/or flowchart illustration, can be implemented by special purpose hardware-based systems which perform the specified functions or acts, or combinations of special purpose hardware and computer instructions.
The units or modules described in the embodiments of the present application may be implemented by software, or may be implemented by hardware. The described units or modules may also be provided in a processor, for example, the units may be software programs provided in a computer or a mobile smart device, or may be separately configured hardware devices. Wherein the names of the units or modules do not in some cases constitute a limitation of the units or modules themselves.
The foregoing description is only of the preferred embodiments of the present application and is presented as a description of the principles of the technology being utilized. It will be appreciated by persons skilled in the art that the scope of the invention referred to in this application is not limited to the specific combinations of features described above, but also covers other embodiments which may be formed by any combination of features described above or their equivalents without departing from the spirit of the application. Such as the above-described features and technical features having similar functions (but not limited to) disclosed in the present application are replaced with each other.
Claims (5)
1. A blockchain JVM application method, wherein a JVM is configured with a custom secondary loading packet, the method being applicable to blockchain nodes, the method comprising:
creating jvm execution threads and jvm query threads respectively, and loading the secondary loading package;
in response to the jvm execution thread receiving a transaction execution parameter for a first transaction sent by a first thread of a blockchain execution module:
blocking the first thread;
the jvm execution thread calls a contract loading method of the secondary loading packet to judge whether a first contract corresponding to the first transaction is loaded and cached according to the transaction execution parameters:
if not, loading the first contract through the contract loading method, caching byte codes of the first contract, and executing the first transaction through the first contract;
if yes, executing the first transaction through the first contract;
returning to the first thread;
in response to receiving a number of query requests, concurrently responding to each of the query requests by:
the contract loading method is called to judge whether the corresponding second contract is loaded and cached according to the first query request:
if not, loading the second contract through the contract loading method, caching byte codes of the second contract, and creating a second thread by the jvm query thread, wherein the second thread executes the query requested by the first query request through the second contract and returns a query result;
if so, the jvm query thread creates a third thread that executes the query requested by the first query request via the second contract and returns the query result.
2. The method of claim 1, wherein said loading the secondary load packet comprises:
analyzing and caching a first transaction execution method, a first query method and the contract loading method in the secondary loading package;
the first transaction execution method is used for analyzing and calling the transaction execution method of the cached contract, and the first query method is used for analyzing and calling the query method of the cached contract.
3. The method of claim 1, wherein a native type blockchain interface is configured in a java compiler of a blockchain node, the blockchain interface including an account type interface, a status database type interface, and a local database type interface.
4. An apparatus, the apparatus comprising:
one or more processors;
a memory for storing one or more programs,
the one or more programs, when executed by the one or more processors, cause the one or more processors to perform the method of any of claims 1-3.
5. A storage medium storing a computer program, characterized in that the program, when executed by a processor, implements the method according to any one of claims 1-3.
Priority Applications (1)
| Application Number | Priority Date | Filing Date | Title |
|---|---|---|---|
| CN202011279724.6A CN112363804B (en) | 2020-11-16 | 2020-11-16 | Blockchain JVM application method, device and storage medium |
Applications Claiming Priority (1)
| Application Number | Priority Date | Filing Date | Title |
|---|---|---|---|
| CN202011279724.6A CN112363804B (en) | 2020-11-16 | 2020-11-16 | Blockchain JVM application method, device and storage medium |
Publications (2)
| Publication Number | Publication Date |
|---|---|
| CN112363804A CN112363804A (en) | 2021-02-12 |
| CN112363804B true CN112363804B (en) | 2024-01-26 |
Family
ID=74515039
Family Applications (1)
| Application Number | Title | Priority Date | Filing Date |
|---|---|---|---|
| CN202011279724.6A Active CN112363804B (en) | 2020-11-16 | 2020-11-16 | Blockchain JVM application method, device and storage medium |
Country Status (1)
| Country | Link |
|---|---|
| CN (1) | CN112363804B (en) |
Families Citing this family (1)
| Publication number | Priority date | Publication date | Assignee | Title |
|---|---|---|---|---|
| CN113094395B (en) * | 2021-03-19 | 2022-05-24 | 杭州复杂美科技有限公司 | Data query method, computer device and storage medium |
Citations (3)
| Publication number | Priority date | Publication date | Assignee | Title |
|---|---|---|---|---|
| CN108830720A (en) * | 2018-06-21 | 2018-11-16 | 北京京东尚科信息技术有限公司 | Intelligent contract operation method, device, system and computer readable storage medium |
| CN110532038A (en) * | 2019-08-19 | 2019-12-03 | 杭州趣链科技有限公司 | A kind of parallel execution method based on Java intelligence contract |
| CN111770205A (en) * | 2020-08-31 | 2020-10-13 | 支付宝(杭州)信息技术有限公司 | Method, block chain node, system and storage medium for executing intelligent contract |
Family Cites Families (1)
| Publication number | Priority date | Publication date | Assignee | Title |
|---|---|---|---|---|
| CN110249307B (en) * | 2018-12-29 | 2022-05-31 | 创新先进技术有限公司 | System and method for executing native contracts on blockchains |
-
2020
- 2020-11-16 CN CN202011279724.6A patent/CN112363804B/en active Active
Patent Citations (3)
| Publication number | Priority date | Publication date | Assignee | Title |
|---|---|---|---|---|
| CN108830720A (en) * | 2018-06-21 | 2018-11-16 | 北京京东尚科信息技术有限公司 | Intelligent contract operation method, device, system and computer readable storage medium |
| CN110532038A (en) * | 2019-08-19 | 2019-12-03 | 杭州趣链科技有限公司 | A kind of parallel execution method based on Java intelligence contract |
| CN111770205A (en) * | 2020-08-31 | 2020-10-13 | 支付宝(杭州)信息技术有限公司 | Method, block chain node, system and storage medium for executing intelligent contract |
Also Published As
| Publication number | Publication date |
|---|---|
| CN112363804A (en) | 2021-02-12 |
Similar Documents
| Publication | Publication Date | Title |
|---|---|---|
| US6253226B1 (en) | Duration-based memory management of complex objects | |
| JP3546394B2 (en) | Method and system for transferring remote procedure calls and responses over a network | |
| US5875335A (en) | Parameter marshaling techniques for dynamic object-oriented programming languages | |
| US6202208B1 (en) | Patching environment for modifying a Java virtual machine and method | |
| US5675804A (en) | System and method for enabling a compiled computer program to invoke an interpretive computer program | |
| US10261764B2 (en) | Handling value types | |
| US6779187B1 (en) | Method and system for dynamic interception of function calls to dynamic link libraries into a windowed operating system | |
| US6119145A (en) | Multithreaded client application storing a separate context for each transaction thus allowing threads to resume transactions started by other client threads | |
| US6067577A (en) | Dynamic method resolution for native methods in a dynamic object-oriented programming language | |
| US10684827B2 (en) | Generating dynamic modular proxies | |
| EP0778521B1 (en) | System and method for runtime optimization of private variable function calls in a secure interpreter | |
| US10140119B2 (en) | Modular serialization | |
| US11599346B2 (en) | Accessing a migrated member in an updated type | |
| US6877163B1 (en) | Method and system for dynamic proxy classes | |
| US6353860B1 (en) | Methods and apparatus for managing collections of objects | |
| US8261248B2 (en) | System and method of executing a dynamic program in a structured environment | |
| US10719337B2 (en) | Container-based language runtime loading an isolated method | |
| US20210182040A1 (en) | Delegating Bytecode Runtime Compilation to Serverless Environment | |
| US11645129B2 (en) | Dynamically-imposed field and method type restrictions for managed execution environments | |
| JP2000515279A (en) | Method and apparatus for performing distributed object invocation using proxy and memory allocation | |
| CN112363804B (en) | Blockchain JVM application method, device and storage medium | |
| US10120777B1 (en) | Remediating serialization incompatibilities | |
| US20210036944A1 (en) | Ranking service implementations for a service interface | |
| US10802855B2 (en) | Producing an internal representation of a type based on the type's source representation | |
| CN113032468A (en) | Data writing method, device and computer readable storage medium |
Legal Events
| Date | Code | Title | Description |
|---|---|---|---|
| PB01 | Publication | ||
| PB01 | Publication | ||
| SE01 | Entry into force of request for substantive examination | ||
| SE01 | Entry into force of request for substantive examination | ||
| TA01 | Transfer of patent application right |
Effective date of registration: 20231226 Address after: 1101-1, 11th Floor, Building 1, No. 22 Ronghua Middle Road, Economic and Technological Development Zone, Daxing District, Beijing, 100176 Applicant after: Beijing Travel World Network Technology Co.,Ltd. Address before: 310000 Room 702, 7th Floor, Building 6, East Software Park, No. 90 Wensan Road, Xihu District, Hangzhou City, Zhejiang Province Applicant before: HANGZHOU FUZAMEI TECHNOLOGY Co.,Ltd. |
|
| TA01 | Transfer of patent application right | ||
| GR01 | Patent grant | ||
| GR01 | Patent grant |